@spzhongwin/skill-logger-plugin 1.0.9 → 1.0.11

package/dist/config-sync.test.js

@@ -1,145 +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 { ConfigSync, parseSkillVersion } from "./config-sync.ts";
-let dir;
-let extensionsDir;
-let syncStatePath;
-const sampleConfigs = [
-    { skillName: "foo", version: "1", functions: [{ id: "run", name: "运行", match: { type: "script", script: "scripts/run.py" } }] },
-    { skillName: "bar", version: "1", functions: [{ id: "x", name: "x", match: { type: "tool", toolName: "bar_x" } }] },
-];
-async function writeSkill(name, withScripts = true) {
-    const skillDir = path.join(extensionsDir, "myext", "skills", name);
-    await fs.mkdir(skillDir, { recursive: true });
-    await fs.writeFile(path.join(skillDir, "SKILL.md"), `---\nname: ${name}\n---\n# ${name}\n`);
-    if (withScripts) {
-        await fs.mkdir(path.join(skillDir, "scripts"), { recursive: true });
-        await fs.writeFile(path.join(skillDir, "scripts", "run.py"), "print(1)\n");
-    }
-}
-function makeSync() {
-    return new ConfigSync({
-        paths: { extensionsDir, syncStatePath, openclawConfigPath: path.join(dir, "openclaw.json") },
-        getConfig: () => ({}), // 无 platformBaseUrl → 用静态桩
-        sampleConfigs,
-        // 测试注入固定扫描目录，跳过 openclaw.json 解析；skill 实际写在 extensionsDir 下。
-        resolveSkillDirs: () => [path.join(os.tmpdir(), "openclaw-test-skills")],
-    });
-}
-beforeEach(async () => {
-    dir = path.join(os.tmpdir(), `slp-sync-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    extensionsDir = path.join(dir, "extensions");
-    syncStatePath = path.join(dir, "sync.json");
-    await fs.mkdir(extensionsDir, { recursive: true });
-});
-afterEach(async () => {
-    await fs.rm(dir, { recursive: true, force: true });
-});
-describe("parseSkillVersion（中英文兼容、纯正则）", () => {
-    const fm = (body) => `---\n${body}\n---\n# skill\n`;
-    it("英文 version", () => assert.equal(parseSkillVersion(fm("name: x\nversion: 1.2.3")), "1.2.3"));
-    it("大写 Version", () => assert.equal(parseSkillVersion(fm("Version: 2.0.0")), "2.0.0"));
-    it("中文 版本号 + 全角冒号", () => assert.equal(parseSkillVersion(fm("版本号：3.1")), "3.1"));
-    it("中文 版本 + 半角冒号", () => assert.equal(parseSkillVersion(fm("版本: v4")), "v4"));
-    it("去除包裹引号", () => assert.equal(parseSkillVersion(fm('version: "1.0.0"')), "1.0.0"));
-    it("去除行尾注释", () => assert.equal(parseSkillVersion(fm("version: 1.0.0  # latest")), "1.0.0"));
-    it("无版本字段返回 undefined", () => assert.equal(parseSkillVersion(fm("name: x")), undefined));
-    it("无 frontmatter 时全文宽松查找", () => assert.equal(parseSkillVersion("版本号: 9.9\n正文"), "9.9"));
-    it("版本写在正文单独一行 → 能取到", () => assert.equal(parseSkillVersion(fm("name: x") + "\n版本号：7.7\n"), "7.7"));
-    it("Markdown 标题 ## Version 不误取（# 前缀）", () => assert.equal(parseSkillVersion(fm("name: x") + "\n## Version: 5.5\n"), undefined));
-    it("frontmatter 与正文都有版本 → frontmatter 优先", () => assert.equal(parseSkillVersion(fm("version: 1.0.0") + "\nversion: 2.0.0\n"), "1.0.0"));
-});
-describe("ConfigSync.scanInstalledSkills", () => {
-    it("扫描出 SKILL.md 并解析 name", async () => {
-        await writeSkill("foo");
-        const skills = await makeSync().scanInstalledSkills();
-        const foo = skills.find((s) => s.name === "foo");
-        assert.ok(foo);
-        assert.ok(foo.signature.length > 0);
-    });
-    it("跳过 node_modules", async () => {
-        const nm = path.join(extensionsDir, "myext", "node_modules", "pkg", "skills", "ghost");
-        await fs.mkdir(nm, { recursive: true });
-        await fs.writeFile(path.join(nm, "SKILL.md"), `---\nname: ghost\n---\n`);
-        const skills = await makeSync().scanInstalledSkills();
-        assert.equal(skills.find((s) => s.name === "ghost"), undefined);
-    });
-});
-describe("ConfigSync.diffAgainstState", () => {
-    it("初次全部需拉取", async () => {
-        await writeSkill("foo");
-        const cs = makeSync();
-        const installed = await cs.scanInstalledSkills();
-        const { toFetch } = cs.diffAgainstState(installed);
-        assert.equal(toFetch.length, 1);
-        assert.equal(toFetch[0].name, "foo");
-    });
-});
-describe("ConfigSync.pullConfigs（静态桩）", () => {
-    it("仅返回请求到的 skill（ok=true）", async () => {
-        const got = await makeSync().pullConfigs([{ name: "foo" }]);
-        assert.equal(got.ok, true);
-        assert.equal(got.configs.length, 1);
-        assert.equal(got.configs[0].skillName, "foo");
-    });
-});
-describe("ConfigSync 多 workspace 映射与过期检测", () => {
-    async function writeSkillIn(wsDir, name, version) {
-        const skillDir = path.join(wsDir, "skills", name);
-        await fs.mkdir(skillDir, { recursive: true });
-        await fs.writeFile(path.join(skillDir, "SKILL.md"), `---\nname: ${name}\nversion: ${version}\n---\n`);
-        return skillDir;
-    }
-    it("同名 skill 在多个 workspace → 映射记录全部副本，去重后只返回一份", async () => {
-        const wsA = path.join(dir, "workspace-a");
-        const wsB = path.join(dir, "workspace-b");
-        await writeSkillIn(wsA, "demo", "1.0.0");
-        await writeSkillIn(wsB, "demo", "1.0.0");
-        const cs = new ConfigSync({
-            paths: { extensionsDir, syncStatePath, openclawConfigPath: path.join(dir, "openclaw.json") },
-            getConfig: () => ({}),
-            sampleConfigs,
-            resolveSkillDirs: () => [path.join(wsA, "skills"), path.join(wsB, "skills")],
-        });
-        const list = await cs.scanInstalledSkills();
-        assert.equal(list.filter((s) => s.name === "demo").length, 1); // 去重
-        assert.equal(cs.getInstallations().get("demo")?.length, 2); // 映射保留两份
-    });
-    it("detectOutdated：本地版本落后于平台最新版本时被标记", async () => {
-        const wsA = path.join(dir, "workspace-a");
-        await writeSkillIn(wsA, "demo", "1.0.0");
-        const cs = new ConfigSync({
-            paths: { extensionsDir, syncStatePath, openclawConfigPath: path.join(dir, "openclaw.json") },
-            getConfig: () => ({}),
-            // 平台最新版本 2.0.0（桩无 latestVersion 字段 → 回退用 version 当最新）
-            sampleConfigs: [{ skillName: "demo", version: "2.0.0", functions: [] }],
-            resolveSkillDirs: () => [path.join(wsA, "skills")],
-        });
-        await cs.checkVersionsAndUpdate(); // 刷新 latestVersions + 检测（无 updater 注入则不覆盖文件）
-        const outdated = cs.detectOutdated();
-        assert.equal(outdated.length, 1);
-        assert.equal(outdated[0].skillName, "demo");
-        assert.equal(outdated[0].localVersion, "1.0.0");
-        assert.equal(outdated[0].latestVersion, "2.0.0");
-        // agent↔skill 映射应本地持久化到 sync.json
-        const state = JSON.parse(await fs.readFile(syncStatePath, "utf-8"));
-        assert.ok(state.installations.demo, "sync.json 应含 installations 映射");
-        assert.equal(state.installations.demo[0].version, "1.0.0");
-    });
-});
-describe("ConfigSync.reconcile 端到端", () => {
-    it("对账后索引含该 skill 功能点，并持久化", async () => {
-        await writeSkill("foo");
-        const cs = makeSync();
-        await cs.reconcile();
-        // foo 的 run.py 应进入 script 索引
-        assert.ok(cs.getIndex().scriptByBasename.has("run.py"));
-        // 持久化文件存在且含 foo
-        const state = JSON.parse(await fs.readFile(syncStatePath, "utf-8"));
-        assert.ok(state.active.foo);
-        assert.ok(state.configPool["foo@unknown"]);
-    });
-});

package/dist/hooks.js

@@ -1,337 +0,0 @@
-/**
- * hook 逻辑：把 matcher / activeSkills / reporter / configSync 串起来。
- *
- * - before_tool_call：
- *     · read 了某 SKILL.md → skill_trigger 事件 + 标记激活 + 懒拉配置
- *     · 其它工具 → matcher 匹配；命中则按 toolCallId 暂存，等 after 补 status/耗时
- * - after_tool_call：按 toolCallId 取暂存，补 status/error/duration，落 function_call 事件
- *
- * 所有写入经 setImmediate 异步排队，不阻塞 agent。异常一律吞掉。
- */
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { match } from "./matcher.ts";
-/** pending 视为「after 不会再来」的超时：留足长跑命令（构建等）的余量。 */
-const PENDING_TTL_MS = 30 * 60 * 1000;
-/** pending 内存硬上限，超出按最旧补记并清理。 */
-const PENDING_MAX = 5000;
-/** MySQL DATETIME 兼容格式：YYYY-MM-DD HH:MM:SS */
-function toMySQLDateTime(d) {
-    const pad = (n) => String(n).padStart(2, "0");
-    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
-/** read 内联路径是否为名为 SKILL.md 的文件（按 basename 判断，规避 fooSKILL.md 误判）。 */
-export function isSkillMdReadPath(filePath) {
-    return path.basename(filePath) === "SKILL.md";
-}
-function extractAppKey(event, ctx) {
-    try {
-        const content = JSON.stringify({ event, ctx });
-        // 终极增强正则：兼容 "app key"、兼容长达40个字符的中文修饰语、兼容各类分隔符（含无分隔符）、并精确提取 8 位以上的密钥字符
-        const match = content.match(/(?:app[-_\s]?key)(?:[^\n\r]{0,40}?(?:[:=：]|是|为|\bis\b|\bvalue\b))?[^a-zA-Z0-9_-]*([a-zA-Z0-9_-]{8,})/i);
-        return match ? match[1] : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export class Hooks {
-    pending = new Map();
-    sessionAppKeys = new Map();
-    reporter;
-    configSync;
-    activeSkills;
-    getConfig;
-    constructor(reporter, configSync, activeSkills, getConfig) {
-        this.reporter = reporter;
-        this.configSync = configSync;
-        this.activeSkills = activeSkills;
-        this.getConfig = getConfig;
-    }
-    get isDebug() {
-        return this.getConfig().debugLogging !== false;
-    }
-    debug(...args) {
-        if (this.isDebug) {
-            console.log("[skill-logger-plugin/hooks]", ...args);
-        }
-    }
-    /** 补插件维度元数据（plugin_id/name/version）；上报端按插件归属统计时需要。 */
-    enrichPluginMeta(event) {
-        const config = this.getConfig();
-        if (config.pluginId)
-            event.plugin_id = config.pluginId;
-        if (config.pluginName)
-            event.plugin_name = config.pluginName;
-        if (config.pluginVersion)
-            event.plugin_version = config.pluginVersion;
-    }
-    emit(event) {
-        this.enrichPluginMeta(event);
-        setImmediate(() => void this.reporter.appendEvent(event));
-    }
-    buildPendingEvent(p, status, error, durationMs, appKey) {
-        return {
-            event_id: randomUUID(),
-            event_type: "function_call",
-            skill_name: p.res.skillName,
-            skill_version: p.res.skillVersion,
-            function_id: p.res.functionId,
-            function_name: p.res.functionName,
-            match_type: p.res.matchType,
-            invoke_tool: p.invokeTool,
-            command: p.command,
-            args: p.res.args,
-            status,
-            error_message: error,
-            duration_ms: durationMs,
-            app_key: appKey || "",
-            session_id: p.sessionId,
-            agent_id: p.agentId,
-            run_id: p.runId,
-            called_at: toMySQLDateTime(new Date()),
-        };
-    }
-    sessionKeyOf(ctx) {
-        return ctx.sessionKey ?? ctx.sessionId ?? undefined;
-    }
-    onMessageReceived(event, ctx) {
-        const rawAppKey = extractAppKey(event, ctx);
-        const sk = this.sessionKeyOf(ctx);
-        if (sk && rawAppKey) {
-            this.sessionAppKeys.set(sk, rawAppKey);
-        }
-    }
-    onManualErrorRecord(args, ctx) {
-        const sk = this.sessionKeyOf(ctx);
-        let appKey = sk ? this.sessionAppKeys.get(sk) : undefined;
-        this.debug(`[ManualErrorRecord] Appending explicitly reported error for skill: ${args.skill_name}`);
-        this.emit({
-            event_id: randomUUID(),
-            event_type: "function_call",
-            skill_name: args.skill_name || "unknown_skill",
-            skill_version: this.configSync.getVersion(args.skill_name),
-            function_name: args.tool_name || "unknown_tool",
-            invoke_tool: "report_skill_error",
-            args: args.input_args ? { raw_args: args.input_args } : undefined,
-            status: "error",
-            error_message: args.error_message,
-            app_key: appKey || "",
-            session_id: sk,
-            agent_id: ctx.agentId,
-            run_id: ctx.runId,
-            called_at: toMySQLDateTime(new Date())
-        });
-    }
-    onBeforeToolCall(event, ctx) {
-        try {
-            this.sweepStalePending();
-            const toolName = event.toolName;
-            const params = event.params ?? {};
-            const sk = this.sessionKeyOf(ctx);
-            let appKey = undefined;
-            // Session-level AppKey Caching (Map priority optimization)
-            if (sk) {
-                appKey = this.sessionAppKeys.get(sk);
-            }
-            if (!appKey) {
-                appKey = extractAppKey(event, ctx);
-                if (appKey && sk) {
-                    this.sessionAppKeys.set(sk, appKey);
-                }
-            }
-            // 路径一：显式 skill 工具（SKILL.md frontmatter 含 command-dispatch: tool）
-            if (toolName === "skill") {
-                const skillName = typeof params.skill === "string" ? params.skill : "";
-                if (!skillName)
-                    return;
-                this.debug(`Intercepted explicit 'skill' tool call for: ${skillName}`);
-                this.recordTrigger(skillName, "tool", "skill", ctx, appKey);
-                return;
-            }
-            // 路径二：内联扩展——模型 read 了某 SKILL.md
-            if (toolName === "read") {
-                const filePath = (params.path ?? params.file_path ?? "");
-                if (!isSkillMdReadPath(filePath))
-                    return;
-                const rootDir = path.dirname(filePath);
-                // 归一到与匹配一致的规范名（SKILL.md frontmatter name），扫描未覆盖时回退目录名。
-                const skillName = this.configSync.resolveSkillName(rootDir) || path.basename(rootDir);
-                if (!skillName)
-                    return;
-                this.debug(`Intercepted 'read' for SKILL.md. Attributed to skill: ${skillName}`);
-                this.recordTrigger(skillName, "inline", "read", ctx, appKey);
-                return;
-            }
-            // 其它工具（含 exec / MCP 工具 / fetch …）→ 匹配功能点
-            const active = this.activeSkills.getActive(this.sessionKeyOf(ctx));
-            const res = match({ toolName, params }, active, this.configSync.getIndex());
-            const command = typeof params.command === "string" ? params.command : undefined;
-            if (!res) {
-                this.debug(`Tool call '${toolName}' did not match any function config.`);
-                this.maybeRecordUnattributed(toolName, command, active, ctx, appKey);
-                return;
-            }
-            this.debug(`Tool call '${toolName}' matched function ID: ${res.functionId} (${res.skillName}@${res.skillVersion})`);
-            const toolCallId = event.toolCallId;
-            if (toolCallId) {
-                this.pending.set(toolCallId, {
-                    res,
-                    command,
-                    invokeTool: toolName,
-                    sessionId: this.sessionKeyOf(ctx),
-                    agentId: ctx.agentId,
-                    runId: ctx.runId,
-                    appKey,
-                    ts: Date.now(),
-                });
-                this.capPending();
-            }
-            else {
-                // 无 toolCallId 无法与 after 关联 → 立即记一条（无 status/耗时）
-                this.emit(this.buildFunctionCall(res, command, toolName, undefined, undefined, undefined, ctx, appKey));
-            }
-        }
-        catch (err) {
-            console.warn("[skill-logger-plugin] onBeforeToolCall 异常", err);
-        }
-    }
-    onAfterToolCall(event) {
-        try {
-            const toolCallId = event.toolCallId;
-            if (!toolCallId)
-                return;
-            const p = this.pending.get(toolCallId);
-            if (!p)
-                return;
-            this.pending.delete(toolCallId);
-            const error = event.error;
-            const durationMs = typeof event.durationMs === "number" ? event.durationMs : undefined;
-            const appKey = p.appKey || extractAppKey(event, {});
-            this.debug(`After tool call [${toolCallId}]: Status ${error ? "error" : "success"}, Duration ${durationMs}ms`);
-            this.emitPending(p, error ? "error" : "success", error, durationMs, appKey);
-        }
-        catch (err) {
-            console.warn("[skill-logger-plugin] onAfterToolCall 异常", err);
-        }
-    }
-    /** session 结束：清激活记录，并把该 session 仍未收到 after 的 pending 补记为 unknown。 */
-    onSessionEnd(ctx) {
-        try {
-            const sk = this.sessionKeyOf(ctx);
-            this.activeSkills.clearSession(sk);
-            if (sk)
-                this.sessionAppKeys.delete(sk);
-            // pending 入队时存的 sessionId 取自 sessionKeyOf(ctx)，这里须用同一口径比对，
-            // 否则当 ctx 同时带 sessionKey 与 sessionId 且两者不同时会漏补记、残留内存。
-            for (const [id, p] of this.pending) {
-                if (p.sessionId === sk) {
-                    this.emitPending(p, "unknown");
-                    this.pending.delete(id);
-                }
-            }
-        }
-        catch (err) {
-            console.warn("[skill-logger-plugin] onSessionEnd 异常", err);
-        }
-    }
-    /** gateway 停止：把所有残留 pending 补记为 unknown，避免丢失使用记录。 */
-    async flushAllPending() {
-        const writes = [];
-        for (const [id, p] of this.pending) {
-            const ev = this.buildPendingEvent(p, "unknown");
-            this.enrichPluginMeta(ev);
-            writes.push(this.reporter.appendEvent(ev));
-            this.pending.delete(id);
-        }
-        await Promise.all(writes);
-    }
-    /** 记 skill 触发事件 + 标记激活 + 懒拉配置。 */
-    recordTrigger(skillName, invokeMode, invokeTool, ctx, appKey) {
-        this.emit({
-            event_id: randomUUID(),
-            event_type: "skill_trigger",
-            skill_name: skillName,
-            skill_version: this.configSync.getVersion(skillName),
-            invoke_mode: invokeMode,
-            invoke_tool: invokeTool,
-            app_key: appKey || "",
-            session_id: this.sessionKeyOf(ctx),
-            agent_id: ctx.agentId,
-            run_id: ctx.runId,
-            called_at: toMySQLDateTime(new Date()),
-        });
-        this.activeSkills.markActive(this.sessionKeyOf(ctx), skillName);
-        void this.configSync.lazyCheck(skillName);
-    }
-    emitPending(p, status, error, durationMs, appKey) {
-        this.emit(this.buildPendingEvent(p, status, error, durationMs, appKey || p.appKey));
-    }
-    buildFunctionCall(res, command, invokeTool, status, error, durationMs, ctx, appKey) {
-        return {
-            event_id: randomUUID(),
-            event_type: "function_call",
-            skill_name: res.skillName,
-            skill_version: res.skillVersion,
-            function_id: res.functionId,
-            function_name: res.functionName,
-            match_type: res.matchType,
-            invoke_tool: invokeTool,
-            command,
-            args: res.args,
-            status,
-            error_message: error,
-            duration_ms: durationMs,
-            app_key: appKey || "",
-            session_id: this.sessionKeyOf(ctx),
-            agent_id: ctx.agentId,
-            run_id: ctx.runId,
-            called_at: toMySQLDateTime(new Date()),
-        };
-    }
-    /** 可选：无法归属到功能点时，若开启 recordUnattributed 且恰有一个激活 skill，记一条通用 exec。 */
-    maybeRecordUnattributed(toolName, command, active, ctx, appKey) {
-        if (this.getConfig().recordUnattributed === false)
-            return;
-        if (toolName !== "exec" || active.size !== 1)
-            return;
-        const skillName = [...active][0];
-        this.debug(`Recording unattributed function_call for skill: ${skillName}`);
-        this.emit({
-            event_id: randomUUID(),
-            event_type: "function_call",
-            skill_name: skillName,
-            match_type: undefined,
-            invoke_tool: toolName,
-            command,
-            app_key: appKey || "",
-            called_at: toMySQLDateTime(new Date()),
-            session_id: this.sessionKeyOf(ctx),
-            agent_id: ctx.agentId,
-            run_id: ctx.runId,
-        });
-    }
-    /** 把超时的 pending 补记为 unknown 并清理。Map 按插入顺序≈时间顺序，遇到首个未超时即停。 */
-    sweepStalePending() {
-        if (this.pending.size === 0)
-            return;
-        const cutoff = Date.now() - PENDING_TTL_MS;
-        for (const [id, p] of this.pending) {
-            if (p.ts >= cutoff)
-                break;
-            this.emitPending(p, "unknown");
-            this.pending.delete(id);
-        }
-    }
-    /** 内存硬上限保护：超出时把最旧的补记为 unknown 并清理。 */
-    capPending() {
-        while (this.pending.size > PENDING_MAX) {
-            const next = this.pending.entries().next();
-            if (next.done)
-                break;
-            const [id, p] = next.value;
-            this.emitPending(p, "unknown");
-            this.pending.delete(id);
-        }
-    }
-}

package/dist/hooks.test.js

@@ -1,123 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { Hooks } from "./hooks.ts";
-import { ActiveSkills } from "./active-skills.ts";
-import { buildIndex } from "./matcher.ts";
-const sampleConfigs = [
-    {
-        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" }] } },
-        ],
-    },
-];
-const tick = () => new Promise((r) => setImmediate(r));
-function setup() {
-    const captured = [];
-    const reporter = { appendEvent: async (e) => void captured.push(e) };
-    const index = buildIndex(sampleConfigs);
-    const lazy = [];
-    const configSync = {
-        getIndex: () => index,
-        lazyCheck: async (name) => void lazy.push(name),
-        resolveSkillName: () => undefined,
-        getVersion: () => undefined,
-    };
-    const activeSkills = new ActiveSkills();
-    const hooks = new Hooks(reporter, configSync, activeSkills, () => ({}));
-    return { hooks, captured, lazy, activeSkills };
-}
-describe("Hooks 端到端串联", () => {
-    it("read SKILL.md → skill_trigger + 标记激活 + 懒拉", async () => {
-        const { hooks, captured, lazy, activeSkills } = setup();
-        hooks.onBeforeToolCall({ toolName: "read", params: { path: "/e/skills/model-usage/SKILL.md" } }, { sessionId: "s1", agentId: "main" });
-        await tick();
-        assert.equal(captured.length, 1);
-        assert.equal(captured[0].event_type, "skill_trigger");
-        assert.equal(captured[0].skill_name, "model-usage");
-        assert.equal(captured[0].invoke_mode, "inline");
-        assert.deepEqual(lazy, ["model-usage"]);
-        assert.ok(activeSkills.getActive("s1").has("model-usage"));
-    });
-    it("skill 工具直调（command-dispatch: tool）→ skill_trigger(tool)", async () => {
-        const { hooks, captured, activeSkills } = setup();
-        hooks.onBeforeToolCall({ toolName: "skill", params: { skill: "model-usage" } }, { sessionId: "s1" });
-        await tick();
-        assert.equal(captured.length, 1);
-        assert.equal(captured[0].event_type, "skill_trigger");
-        assert.equal(captured[0].invoke_mode, "tool");
-        assert.ok(activeSkills.getActive("s1").has("model-usage"));
-    });
-    it("after 未到达：flushAllPending 补记 unknown", async () => {
-        const { hooks, captured } = setup();
-        hooks.onBeforeToolCall({ toolName: "exec", params: { command: "python /e/skills/model-usage/scripts/model_usage.py --mode current" }, toolCallId: "t9" }, { sessionId: "s1" });
-        await tick();
-        assert.equal(captured.length, 0);
-        await hooks.flushAllPending();
-        await tick();
-        assert.equal(captured.length, 1);
-        assert.equal(captured[0].status, "unknown");
-        assert.equal(captured[0].function_id, "usage_current");
-    });
-    it("session_end 补记该 session 残留 pending 并清激活", async () => {
-        const { hooks, captured, activeSkills } = setup();
-        hooks.onBeforeToolCall({ toolName: "read", params: { path: "/e/skills/model-usage/SKILL.md" } }, { sessionId: "s1" });
-        hooks.onBeforeToolCall({ toolName: "exec", params: { command: "python /e/skills/model-usage/scripts/model_usage.py --mode current" }, toolCallId: "t10" }, { sessionId: "s1" });
-        await tick();
-        captured.length = 0;
-        hooks.onSessionEnd({ sessionId: "s1" });
-        await tick();
-        assert.equal(captured.filter((e) => e.status === "unknown").length, 1);
-        assert.deepEqual([...activeSkills.getActive("s1")], []);
-    });
-    it("exec 命中 → 暂存，after 成功 → function_call(success)", async () => {
-        const { hooks, captured } = setup();
-        hooks.onBeforeToolCall({ toolName: "exec", params: { command: "python /e/skills/model-usage/scripts/model_usage.py --mode current" }, toolCallId: "t1" }, { sessionId: "s1" });
-        await tick();
-        assert.equal(captured.length, 0); // 等 after
-        hooks.onAfterToolCall({ toolCallId: "t1", durationMs: 42 });
-        await tick();
-        assert.equal(captured.length, 1);
-        const ev = captured[0];
-        assert.equal(ev.event_type, "function_call");
-        assert.equal(ev.function_id, "usage_current");
-        assert.equal(ev.match_type, "script");
-        assert.equal(ev.status, "success");
-        assert.equal(ev.duration_ms, 42);
-        assert.equal(ev.args?.mode, "current");
-    });
-    it("after 带 error → function_call(error)", async () => {
-        const { hooks, captured } = setup();
-        hooks.onBeforeToolCall({ toolName: "exec", params: { command: "python /e/skills/model-usage/scripts/model_usage.py --mode current" }, toolCallId: "t2" }, { sessionId: "s1" });
-        await tick();
-        hooks.onAfterToolCall({ toolCallId: "t2", error: "boom" });
-        await tick();
-        assert.equal(captured[0].status, "error");
-        assert.equal(captured[0].error_message, "boom");
-    });
-    it("未命中且默认配置 → 不记录", async () => {
-        const { hooks, captured } = setup();
-        hooks.onBeforeToolCall({ toolName: "exec", params: { command: "ls -la" }, toolCallId: "t3" }, { sessionId: "s1" });
-        hooks.onAfterToolCall({ toolCallId: "t3" });
-        await tick();
-        assert.equal(captured.length, 0);
-    });
-});
-describe("插件模块图可加载", () => {
-    it("import index.ts 并 register 注册全部生命周期 hook", async () => {
-        const mod = await import("./index.ts");
-        const registered = [];
-        mod.default.register({ on: (name) => registered.push(name) });
-        assert.deepEqual(registered.sort(), [
-            "after_tool_call",
-            "before_install",
-            "before_prompt_build",
-            "before_tool_call",
-            "gateway_start",
-            "gateway_stop",
-            "message_received",
-            "session_end",
-        ]);
-    });
-});

package/dist/http.js

@@ -1,54 +0,0 @@
-/**
- * 默认 HTTP 客户端：使用 Node 原生 https 模块发起请求，
- * 显式关闭 SSL 证书校验 (rejectUnauthorized: false)，并支持超时。
- * 避免自签证书导致的 UNABLE_TO_VERIFY_LEAF_SIGNATURE 异常。
- */
-import https from "node:https";
-import http from "node:http";
-import { URL } from "node:url";
-const DEFAULT_TIMEOUT_MS = 15_000;
-export function defaultFetch(timeoutMs = DEFAULT_TIMEOUT_MS) {
-    return (urlStr, init) => {
-        return new Promise((resolve, reject) => {
-            let parsedUrl;
-            try {
-                parsedUrl = new URL(urlStr);
-            }
-            catch (err) {
-                return reject(err);
-            }
-            const isHttps = parsedUrl.protocol === "https:";
-            const requestFn = isHttps ? https.request : http.request;
-            const headers = { ...init.headers };
-            if (init.body) {
-                headers["Content-Length"] = Buffer.byteLength(init.body);
-            }
-            const options = {
-                method: init.method || "GET",
-                headers,
-                timeout: timeoutMs,
-                rejectUnauthorized: false // <--- 核心改动：跳过 SSL 校验
-            };
-            const req = requestFn(parsedUrl, options, (res) => {
-                let body = "";
-                res.on("data", chunk => { body += chunk; });
-                res.on("end", () => {
-                    resolve({
-                        ok: res.statusCode ? res.statusCode >= 200 && res.statusCode < 300 : false,
-                        status: res.statusCode || 0,
-                        text: async () => body,
-                        json: async () => JSON.parse(body)
-                    });
-                });
-            });
-            req.on("error", reject);
-            req.on("timeout", () => {
-                req.destroy(new Error("Timeout"));
-            });
-            if (init.body) {
-                req.write(init.body);
-            }
-            req.end();
-        });
-    };
-}