@spzhongwin/skill-logger-plugin 1.0.14 → 1.0.16

package/dist/matcher.test.js

@@ -1,139 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { buildIndex, match, parseFlags, parseKeyValues, pathEndsWith, commandHead, tokenize, } from "./matcher.ts";
-const configs = [
-    {
-        skillName: "model-usage",
-        version: "1.0.0",
-        functions: [
-            { id: "usage_current", name: "当前用量", match: { type: "script", script: "scripts/model_usage.py", argRules: [{ flag: "--mode", value: "current" }] } },
-            { id: "usage_all", name: "全部用量", match: { type: "script", script: "scripts/model_usage.py", argRules: [{ flag: "--mode", value: "all" }] } },
-        ],
-    },
-    {
-        skillName: "openai-whisper-api",
-        version: "1.0.0",
-        functions: [{ id: "transcribe", name: "转写", match: { type: "script", script: "scripts/transcribe.sh" } }],
-    },
-    {
-        skillName: "mcporter",
-        version: "1.0.0",
-        functions: [{ id: "list_issues", name: "列issue", match: { type: "command", command: "mcporter", targetPattern: "call linear.list_issues" } }],
-    },
-    {
-        skillName: "linear-mcp",
-        version: "1.0.0",
-        functions: [
-            { id: "create_issue", name: "建issue", match: { type: "tool", toolName: "linear_create_issue" } },
-            { id: "transcribe_http", name: "转写端点", match: { type: "http", urlContains: "/v1/audio/transcriptions" } },
-        ],
-    },
-];
-const index = buildIndex(configs);
-const noActive = new Set();
-function exec(command) {
-    return { toolName: "exec", params: { command } };
-}
-describe("pathEndsWith / tokenize / commandHead", () => {
-    it("脚本路径按段对齐，规避 fooX.py 误判", () => {
-        assert.equal(pathEndsWith("/a/b/scripts/model_usage.py", "scripts/model_usage.py"), true);
-        assert.equal(pathEndsWith("scripts/model_usage.py", "scripts/model_usage.py"), true);
-        assert.equal(pathEndsWith("/a/xscripts/model_usage.py", "scripts/model_usage.py"), false);
-        assert.equal(pathEndsWith("/a/foomodel_usage.py", "model_usage.py"), false);
-    });
-    it("tokenize 处理引号", () => {
-        assert.deepEqual(tokenize(`a "b c" 'd e' f`), ["a", "b c", "d e", "f"]);
-    });
-    it("commandHead 跳过环境前缀与解释器", () => {
-        assert.equal(commandHead(tokenize("FOO=1 python /x/scripts/y.py --a")), "y.py");
-        assert.equal(commandHead(tokenize("mcporter call linear.list_issues")), "mcporter");
-    });
-});
-describe("parseFlags / parseKeyValues", () => {
-    it("--k v / --k=v / 布尔 flag", () => {
-        const f = parseFlags(tokenize("x --mode current --pretty --n=3 -v"));
-        assert.equal(f.mode, "current");
-        assert.equal(f.pretty, true);
-        assert.equal(f.n, "3");
-        assert.equal(f.v, true);
-    });
-    it("k=v / k:v，跳过 URL", () => {
-        const kv = parseKeyValues(tokenize("call linear.list_issues team=ENG limit:5 url=https://x/y"));
-        assert.equal(kv.team, "ENG");
-        assert.equal(kv.limit, "5");
-        assert.equal(kv.url, undefined); // 含 :// 被跳过
-    });
-});
-describe("match - script", () => {
-    it("按 --mode 细分功能点", () => {
-        const cur = match(exec("python /e/skills/model-usage/scripts/model_usage.py --mode current"), noActive, index);
-        assert.equal(cur?.functionId, "usage_current");
-        assert.equal(cur?.matchType, "script");
-        assert.equal(cur?.args.mode, "current");
-        const all = match(exec("python /e/skills/model-usage/scripts/model_usage.py --mode all --pretty"), noActive, index);
-        assert.equal(all?.functionId, "usage_all");
-    });
-    it("argRules 不满足则不命中该功能点", () => {
-        const r = match(exec("python /e/scripts/model_usage.py --mode none"), noActive, index);
-        assert.equal(r, null);
-    });
-    it("解释器无关：bash 跑 .sh 命中", () => {
-        const r = match(exec("bash /e/openai-whisper-api/scripts/transcribe.sh a.mp3"), noActive, index);
-        assert.equal(r?.functionId, "transcribe");
-    });
-});
-describe("match - command / tool / http", () => {
-    it("command: mcporter call", () => {
-        const r = match(exec("mcporter call linear.list_issues team=ENG"), noActive, index);
-        assert.equal(r?.functionId, "list_issues");
-        assert.equal(r?.matchType, "command");
-        assert.equal(r?.args.team, "ENG");
-    });
-    it("tool: 非 exec 工具直调", () => {
-        const r = match({ toolName: "linear_create_issue", params: { title: "bug" } }, noActive, index);
-        assert.equal(r?.functionId, "create_issue");
-        assert.equal(r?.matchType, "tool");
-        assert.equal(r?.args.title, "bug");
-    });
-    it("http: curl 命中端点", () => {
-        const r = match(exec("curl -s https://api.openai.com/v1/audio/transcriptions -F file=@a.mp3"), noActive, index);
-        assert.equal(r?.functionId, "transcribe_http");
-        assert.equal(r?.matchType, "http");
-    });
-    it("http: fetch 类工具 url 参数命中", () => {
-        const r = match({ toolName: "fetch", params: { url: "https://api.openai.com/v1/audio/transcriptions?x=1" } }, noActive, index);
-        assert.equal(r?.functionId, "transcribe_http");
-        assert.equal(r?.args.x, "1");
-    });
-    it("无匹配返回 null", () => {
-        assert.equal(match(exec("ls -la"), noActive, index), null);
-        assert.equal(match({ toolName: "unknown_tool", params: {} }, noActive, index), null);
-    });
-});
-describe("match - 弱匹配（cd 后相对路径）仅在 skill 激活时采纳", () => {
-    it("仅 basename 相同：未激活 → null，激活 → 命中", () => {
-        // `cd .../openai-whisper-api/scripts && bash transcribe.sh a.mp3`
-        const call = exec("bash transcribe.sh a.mp3");
-        assert.equal(match(call, noActive, index), null);
-        const r = match(call, new Set(["openai-whisper-api"]), index);
-        assert.equal(r?.functionId, "transcribe");
-    });
-    it("强匹配优先于弱匹配", () => {
-        // 同时出现强（全路径）与弱（裸名）token 时取强匹配
-        const r = match(exec("bash /e/openai-whisper-api/scripts/transcribe.sh"), noActive, index);
-        assert.equal(r?.functionId, "transcribe");
-    });
-});
-describe("match - 歧义消解优先 activeSkills", () => {
-    const ambConfigs = [
-        { skillName: "A", version: "1", functions: [{ id: "a", name: "a", match: { type: "tool", toolNamePrefix: "x_" } }] },
-        { skillName: "B", version: "1", functions: [{ id: "b", name: "b", match: { type: "tool", toolNamePrefix: "x_" } }] },
-    ];
-    const ambIndex = buildIndex(ambConfigs);
-    it("无激活时取第一候选", () => {
-        assert.equal(match({ toolName: "x_do", params: {} }, noActive, ambIndex)?.skillName, "A");
-    });
-    it("激活 B 时归属 B", () => {
-        assert.equal(match({ toolName: "x_do", params: {} }, new Set(["B"]), ambIndex)?.skillName, "B");
-    });
-});

package/dist/paths.js

@@ -1,62 +0,0 @@
-/**
- * 集中管理插件用到的所有文件系统路径。
- *
- * 为什么集中：① 单测可注入临时目录；② openclaw 安全策略下插件不读环境变量，
- * 路径在此固定，运行时不依赖外部配置。
- */
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-/** 默认根目录 `~/.openclaw`。 */
-export function openclawHome() {
-    return path.join(os.homedir(), ".openclaw");
-}
-/**
- * 解析所有 agent workspace 下的 skill 扫描目录。
- *
- * 来源：
- *  - 顶层全局 skills：`<home>/skills`
- *  - 默认 workspace：`<agents.defaults.workspace>/skills`（缺省为 `<home>/workspace`）
- *  - 各 agent：`<agents.list[].workspace>/skills`（未显式配置 workspace 的 agent 落到默认）
- *
- * openclaw.json 不存在 / 解析失败 / 字段缺失时，回退到「顶层 skills + 默认 workspace skills」，
- * 至少不弱于历史行为，且整段被 try/catch 包裹，绝不抛。
- */
-export function resolveAgentSkillDirs(home, configPath) {
-    const dirs = new Set();
-    // 永远纳入的兜底目录（即便 openclaw.json 缺失也能工作）。
-    dirs.add(path.join(home, "skills"));
-    const defaultWorkspaceFallback = path.join(home, "workspace");
-    dirs.add(path.join(defaultWorkspaceFallback, "skills"));
-    try {
-        const raw = fs.readFileSync(configPath, "utf-8");
-        const cfg = JSON.parse(raw);
-        const agents = cfg?.agents;
-        const defaultWs = typeof agents?.defaults?.workspace === "string" ? agents.defaults.workspace : defaultWorkspaceFallback;
-        dirs.add(path.join(defaultWs, "skills"));
-        const list = Array.isArray(agents?.list) ? agents.list : [];
-        for (const a of list) {
-            const ws = typeof a?.workspace === "string" ? a.workspace : defaultWs;
-            dirs.add(path.join(ws, "skills"));
-        }
-    }
-    catch {
-        // openclaw.json 不存在 / 非法 JSON / 权限不足 → 用上面的兜底目录，绝不影响插件启动。
-    }
-    return [...dirs];
-}
-/**
- * 生成一组路径。`overrides` 仅供测试注入（如指向临时目录）。
- */
-export function resolvePaths(overrides) {
-    const home = openclawHome();
-    const logsDir = path.join(home, "logs");
-    return {
-        eventsLogPath: path.join(logsDir, "skill-logger-plugin.jsonl"),
-        syncStatePath: path.join(logsDir, "skill-logger-plugin.sync.json"),
-        cooldownStatePath: path.join(logsDir, "skill-logger-plugin.cooldown.json"),
-        extensionsDir: path.join(home, "extensions"),
-        openclawConfigPath: path.join(home, "openclaw.json"),
-        ...overrides,
-    };
-}

package/dist/paths.test.js

@@ -1,49 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { resolveAgentSkillDirs } from "./paths.ts";
-let home;
-beforeEach(async () => {
-    home = path.join(os.tmpdir(), `slp-paths-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(home, { recursive: true });
-});
-afterEach(async () => {
-    await fs.rm(home, { recursive: true, force: true });
-});
-describe("resolveAgentSkillDirs", () => {
-    it("从 openclaw.json 收集各 agent workspace 的 skills 目录（含默认与顶层）", async () => {
-        const cfg = {
-            agents: {
-                defaults: { workspace: path.join(home, "workspace") },
-                list: [
-                    { id: "main" }, // 无 workspace → 落到默认
-                    { id: "coder", workspace: path.join(home, "workspace-coder") },
-                    { id: "proj", workspace: path.join(home, "agency-agents", "proj") },
-                ],
-            },
-        };
-        const configPath = path.join(home, "openclaw.json");
-        await fs.writeFile(configPath, JSON.stringify(cfg));
-        const dirs = resolveAgentSkillDirs(home, configPath);
-        assert.ok(dirs.includes(path.join(home, "skills")), "应含顶层全局 skills");
-        assert.ok(dirs.includes(path.join(home, "workspace", "skills")), "应含默认 workspace skills");
-        assert.ok(dirs.includes(path.join(home, "workspace-coder", "skills")), "应含 coder workspace skills");
-        assert.ok(dirs.includes(path.join(home, "agency-agents", "proj", "skills")), "应含 proj workspace skills");
-        // 去重：main 落到默认 workspace，不应产生重复项
-        assert.equal(new Set(dirs).size, dirs.length);
-    });
-    it("openclaw.json 缺失时回退到顶层 skills + 默认 workspace skills，且不抛", async () => {
-        const dirs = resolveAgentSkillDirs(home, path.join(home, "does-not-exist.json"));
-        assert.ok(dirs.includes(path.join(home, "skills")));
-        assert.ok(dirs.includes(path.join(home, "workspace", "skills")));
-    });
-    it("非法 JSON 不抛，回退到默认目录", async () => {
-        const configPath = path.join(home, "openclaw.json");
-        await fs.writeFile(configPath, "{ not valid json ");
-        const dirs = resolveAgentSkillDirs(home, configPath);
-        assert.ok(dirs.includes(path.join(home, "skills")));
-        assert.ok(dirs.includes(path.join(home, "workspace", "skills")));
-    });
-});

package/dist/reporter.js

@@ -1,267 +0,0 @@
-/**
- * 本地落盘 + 日志轮转 (Log Rotation) + 每 3 分钟批量上报。
- *
- * 设计原则：
- * - events.jsonl 是活跃的写入日志，通过 appendFile 追加。
- * - 上报时，将其 rename 轮转为带有时间戳的文件，隔离写和读，根绝并发读写丢失数据的竞态条件。
- * - 后台处理所有的轮转文件并上报，上报成功后通过 fs.unlink 清理文件。
- * - 失败则保留待下次重试（因为底层 DB 依赖 INSERT IGNORE 处理重复 event_id，所以即使重试时存在部分重复上报也是安全的）。
- * - 所有异常吞掉，绝不阻塞 agent / gateway。
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-import { GitIdentityProvider } from "./identity.ts";
-import { defaultFetch } from "./http.ts";
-const FLUSH_INTERVAL_MS = 3 * 60 * 1000;
-const BATCH_SIZE = 500;
-export class Reporter {
-    paths;
-    getConfig;
-    identityProvider;
-    fetchImpl;
-    timer;
-    /** 防止多次 flush 重入。 */
-    flushing = false;
-    constructor(opts) {
-        this.paths = opts.paths;
-        this.getConfig = opts.getConfig;
-        this.identityProvider = opts.identityProvider ?? new GitIdentityProvider();
-        this.fetchImpl = opts.fetchImpl ?? defaultFetch();
-    }
-    get isDebug() {
-        return this.getConfig().debugLogging !== false;
-    }
-    async writeFallbackLog(level, ...args) {
-        try {
-            const msg = args.map(a => (a instanceof Error) ? (a.stack || a.toString()) : (typeof a === "object" ? JSON.stringify(a) : String(a))).join(" ");
-            const ts = new Date().toISOString();
-            const logLine = `[${ts}] [${level}] [skill-logger-plugin] ${msg}\n`;
-            const logDir = path.dirname(this.paths.eventsLogPath);
-            await fs.mkdir(logDir, { recursive: true });
-            await fs.appendFile(path.join(logDir, "skill-logger.err.log"), logLine);
-            if (level === "INFO" && this.isDebug) {
-                console.log("[skill-logger-plugin/reporter]", ...args);
-            }
-            else if (level === "WARN" || level === "ERROR") {
-                console.warn("[skill-logger-plugin]", ...args);
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    debug(...args) {
-        if (this.isDebug) {
-            void this.writeFallbackLog("INFO", ...args);
-        }
-    }
-    /** 追加一行事件到 events.jsonl（目录不存在自动建）。失败不抛。 */
-    async appendEvent(event) {
-        try {
-            // 防御：截断会导致 MySQL Data Truncation 宕机的超长字段
-            if (typeof event.error_message === "string" && event.error_message.length > 15000) {
-                event.error_message = event.error_message.substring(0, 15000) + "...(truncated)";
-            }
-            if (typeof event.command === "string" && event.command.length > 15000) {
-                event.command = event.command.substring(0, 15000) + "...(truncated)";
-            }
-            let line = "";
-            try {
-                line = JSON.stringify(event);
-                // 防御：防止整个 JSON 过大（如带有 base64 图片的 args）导致 Express 413 Payload Too Large
-                if (line.length > 100000) {
-                    const safeEvent = { ...event, args: { _warning: "args omitted due to excessive size" } };
-                    line = JSON.stringify(safeEvent);
-                }
-            }
-            catch {
-                return; // JSON 序列化失败直接丢弃
-            }
-            await fs.mkdir(path.dirname(this.paths.eventsLogPath), { recursive: true });
-            await fs.appendFile(this.paths.eventsLogPath, line + "\n");
-        }
-        catch (err) {
-            void this.writeFallbackLog("ERROR", "写事件日志失败", this.paths.eventsLogPath, err);
-        }
-    }
-    /** 启动 3 分钟定时上报。 */
-    startTimer() {
-        if (this.timer)
-            return;
-        this.timer = setInterval(() => void this.flush(), FLUSH_INTERVAL_MS);
-        // 不阻止进程退出
-        if (typeof this.timer.unref === "function")
-            this.timer.unref();
-    }
-    /** 停止定时器，并尽力做最后一次 flush。 */
-    async stopTimer() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = undefined;
-        }
-        await this.flush();
-    }
-    linesOf(content) {
-        return content.split("\n").filter((l) => l.trim().length > 0);
-    }
-    async resolveUserInfo(appKey, config) {
-        if (!config.reportBaseUrl)
-            return {};
-        try {
-            const url = config.reportBaseUrl.replace(/\/$/, "") + "/skill_user/resolve";
-            const headers = { "Content-Type": "application/json" };
-            if (config.authToken)
-                headers.Authorization = config.authToken;
-            const res = await this.fetchImpl(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ appKey }),
-            });
-            if (!res.ok) {
-                return { error_message: `resolve user info failed: HTTP ${res.status}` };
-            }
-            const data = typeof res.json === "function" ? await res.json() : {};
-            return (data.user_info || data.userInfo || data.data || {});
-        }
-        catch (err) {
-            return { error_message: `resolve user info failed: ${err instanceof Error ? err.message : String(err)}` };
-        }
-    }
-    async attachUserInfo(events, config) {
-        const appKeys = [...new Set(events.map((event) => event.app_key || "").filter(Boolean))];
-        if (appKeys.length === 0)
-            return events;
-        const byAppKey = new Map();
-        await Promise.all(appKeys.map(async (appKey) => {
-            byAppKey.set(appKey, await this.resolveUserInfo(appKey, config));
-        }));
-        return events.map((event) => {
-            if (!event.app_key)
-                return event;
-            const userInfo = byAppKey.get(event.app_key);
-            if (!userInfo || Object.keys(userInfo).length === 0)
-                return event;
-            return { ...event, user_info: userInfo };
-        });
-    }
-    /**
-     * 读本地队列并分批 POST；每批成功后清理对应本地文件。
-     * 采用日志轮转（Rename）规避读写竞态条件。
-     * 未配置 reportBaseUrl → 直接返回（只落本地，不上报）。
-     */
-    async flush() {
-        if (this.flushing)
-            return;
-        this.flushing = true;
-        try {
-            const config = this.getConfig();
-            if (!config.reportBaseUrl) {
-                void this.writeFallbackLog("WARN", "flush skipped: reportBaseUrl 没有配置！请检查 openclaw.json 插件配置是否正确加载。");
-                return;
-            }
-            const logDir = path.dirname(this.paths.eventsLogPath);
-            // 1. 重命名当前的活跃日志文件为时间戳格式（原子操作，解决读写冲突）
-            try {
-                await fs.access(this.paths.eventsLogPath);
-                const timestamp = Date.now();
-                const rotatedPath = path.join(logDir, `events.${timestamp}.jsonl`);
-                await fs.rename(this.paths.eventsLogPath, rotatedPath);
-                this.debug(`Rotated active log to ${path.basename(rotatedPath)}`);
-            }
-            catch {
-                // 文件不存在，跳过重命名
-            }
-            // 2. 扫描所有轮转的日志文件
-            let files = [];
-            try {
-                const dirEntries = await fs.readdir(logDir);
-                files = dirEntries
-                    .filter(f => f.startsWith("events.") && f.endsWith(".jsonl") && f !== "events.jsonl")
-                    .map(f => path.join(logDir, f));
-            }
-            catch {
-                return; // 目录不存在直接返回
-            }
-            if (files.length === 0) {
-                this.debug("No rotated log files found. flush finished.");
-                return;
-            }
-            this.debug(`Found ${files.length} rotated log files to process.`);
-            const identity = await this.identityProvider.getIdentity();
-            const url = config.reportBaseUrl.replace(/\/$/, "") + "/skill_report/batch";
-            // 3. 逐个处理文件上报
-            for (const filePath of files) {
-                try {
-                    const content = await fs.readFile(filePath, "utf-8");
-                    const lines = this.linesOf(content);
-                    if (lines.length === 0) {
-                        await fs.unlink(filePath); // 空文件直接删除
-                        continue;
-                    }
-                    let cursor = 0;
-                    let allSuccess = true;
-                    while (cursor < lines.length) {
-                        const slice = lines.slice(cursor, cursor + BATCH_SIZE);
-                        const events = [];
-                        for (const line of slice) {
-                            try {
-                                events.push(JSON.parse(line));
-                            }
-                            catch {
-                                // 跳过坏行
-                            }
-                        }
-                        if (events.length === 0) {
-                            cursor += slice.length;
-                            continue;
-                        }
-                        const eventsWithUserInfo = await this.attachUserInfo(events, config);
-                        const body = JSON.stringify({
-                            identity,
-                            ide: "openclaw",
-                            marketplace: "openclaw",
-                            events: eventsWithUserInfo,
-                        });
-                        const headers = { "Content-Type": "application/json" };
-                        if (config.authToken)
-                            headers.Authorization = config.authToken;
-                        const res = await this.fetchImpl(url, { method: "POST", headers, body });
-                        if (!res.ok) {
-                            const errBody = await res.text().catch(() => "无法读取响应体");
-                            await this.writeFallbackLog("ERROR", `批量上报失败 (文件 ${path.basename(filePath)}), HTTP`, res.status, "服务端返回信息:", errBody);
-                            // 防御死循环：如果是由于报文过大(413)或格式错误(400)等业务级拒绝，放弃该批次，不要死锁整个本地队列
-                            if (res.status === 400 || res.status === 413 || res.status === 422) {
-                                await this.writeFallbackLog("WARN", `报文被服务器永久拒绝，丢弃该批次以释放队列`);
-                                cursor += slice.length;
-                                continue;
-                            }
-                            allSuccess = false;
-                            break; // 其他网络或 500 错误：本文件终止处理，留待下轮重试
-                        }
-                        this.debug(`Successfully reported batch of ${events.length} events from ${path.basename(filePath)}`);
-                        cursor += slice.length;
-                    }
-                    // 如果该文件所有的 batch 都上报成功了，将其物理删除
-                    if (allSuccess) {
-                        await fs.unlink(filePath);
-                        this.debug(`Deleted fully processed file: ${path.basename(filePath)}`);
-                    }
-                    else {
-                        // 如果某一批次失败，文件保留。下轮 flush 会把前面成功批次的事件再报一次。
-                        // 但因为 DB 的 skill_logger_events 表 event_id 是唯一键且使用了 INSERT IGNORE，所以数据去重是绝对安全的。
-                        this.debug(`File ${path.basename(filePath)} partially failed. Keeping it for next flush.`);
-                    }
-                }
-                catch (err) {
-                    await this.writeFallbackLog("ERROR", `处理文件 ${path.basename(filePath)} 异常:`, err);
-                }
-            }
-        }
-        catch (err) {
-            await this.writeFallbackLog("ERROR", "flush 整体异常", err);
-        }
-        finally {
-            this.flushing = false;
-        }
-    }
-}

package/dist/reporter.test.js

@@ -1,128 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { Reporter } from "./reporter.ts";
-const identityProvider = {
-    getIdentity: async () => ({ user_id: "", git_name: "n", git_email: "e", machine_id: "m" }),
-};
-function makeEvent(i) {
-    return { event_id: `id${i}`, event_type: "function_call", skill_name: "s", called_at: new Date().toISOString() };
-}
-let dir;
-let paths;
-beforeEach(async () => {
-    dir = path.join(os.tmpdir(), `slp-reporter-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    await fs.mkdir(dir, { recursive: true });
-    paths = {
-        eventsLogPath: path.join(dir, "events.jsonl"),
-    };
-});
-afterEach(async () => {
-    await fs.rm(dir, { recursive: true, force: true });
-});
-/** 缺文件视为空，匹配轮转模型下「上报成功即删除」的形态。 */
-async function readEventsOrEmpty(p) {
-    try {
-        return await fs.readFile(p, "utf-8");
-    }
-    catch {
-        return "";
-    }
-}
-/** 列出已轮转、待上报的日志文件（排除活跃的 events.jsonl）。 */
-async function listRotated(d) {
-    try {
-        const entries = await fs.readdir(d);
-        return entries.filter((f) => f.startsWith("events.") && f.endsWith(".jsonl") && f !== "events.jsonl");
-    }
-    catch {
-        return [];
-    }
-}
-describe("Reporter.appendEvent", () => {
-    it("目录自动创建并追加写", async () => {
-        const r = new Reporter({ paths, getConfig: () => ({}), identityProvider });
-        await r.appendEvent(makeEvent(1));
-        await r.appendEvent(makeEvent(2));
-        const lines = (await fs.readFile(paths.eventsLogPath, "utf-8")).trim().split("\n");
-        assert.equal(lines.length, 2);
-        assert.equal(JSON.parse(lines[1]).event_id, "id2");
-    });
-});
-describe("Reporter.flush", () => {
-    it("未配置 reportBaseUrl 时不上报", async () => {
-        let called = 0;
-        const r = new Reporter({
-            paths,
-            getConfig: () => ({}),
-            identityProvider,
-            fetchImpl: async () => {
-                called++;
-                return { ok: true, status: 200 };
-            },
-        });
-        await r.appendEvent(makeEvent(1));
-        await r.flush();
-        assert.equal(called, 0);
-    });
-    it("成功上报后清理本地日志，再次 flush 不重复发", async () => {
-        const sent = [];
-        const config = { reportBaseUrl: "https://x" };
-        const r = new Reporter({
-            paths,
-            getConfig: () => config,
-            identityProvider,
-            fetchImpl: async (_url, init) => {
-                const body = JSON.parse(String(init.body));
-                sent.push(body.events.length);
-                return { ok: true, status: 200 };
-            },
-        });
-        await r.appendEvent(makeEvent(1));
-        await r.appendEvent(makeEvent(2));
-        await r.flush();
-        await r.flush(); // 无新事件
-        assert.deepEqual(sent, [2]);
-        // 轮转文件已全部上报并删除，活跃日志清空
-        assert.equal(await readEventsOrEmpty(paths.eventsLogPath), "");
-        assert.equal((await listRotated(dir)).length, 0);
-    });
-    it("保留 flush 期间新追加的事件（轮转隔离读写）", async () => {
-        let appendedDuringFlush = false;
-        const r = new Reporter({
-            paths,
-            getConfig: () => ({ reportBaseUrl: "https://x" }),
-            identityProvider,
-            fetchImpl: async () => {
-                if (!appendedDuringFlush) {
-                    appendedDuringFlush = true;
-                    await fs.appendFile(paths.eventsLogPath, JSON.stringify(makeEvent(2)) + "\n");
-                }
-                return { ok: true, status: 200 };
-            },
-        });
-        await r.appendEvent(makeEvent(1));
-        await r.flush();
-        const lines = (await readEventsOrEmpty(paths.eventsLogPath)).trim().split("\n").filter(Boolean);
-        assert.equal(lines.length, 1);
-        assert.equal(JSON.parse(lines[0]).event_id, "id2");
-    });
-    it("上报失败保留轮转文件，下轮重试成功后清空", async () => {
-        let ok = false;
-        const r = new Reporter({
-            paths,
-            getConfig: () => ({ reportBaseUrl: "https://x" }),
-            identityProvider,
-            fetchImpl: async () => ({ ok, status: ok ? 200 : 500 }),
-        });
-        await r.appendEvent(makeEvent(1));
-        await r.flush(); // 失败：轮转文件保留待重试
-        assert.equal((await listRotated(dir)).length, 1);
-        ok = true;
-        await r.flush(); // 成功：清空
-        assert.equal((await listRotated(dir)).length, 0);
-        assert.equal(await readEventsOrEmpty(paths.eventsLogPath), "");
-    });
-});