@spzhongwin/skill-logger-plugin 1.0.9 → 1.0.11

package/dist/semver.js

@@ -1,64 +0,0 @@
-/**
- * 轻量语义化版本比较（纯函数，无依赖）。
- *
- * 仅用于「本地 skill 版本 vs 平台最新版本」的过期判断，不追求完整 semver 规范：
- *  - 容忍前缀 `v`/`V`（如 `v1.2.3`）；
- *  - 比较 `主.次.修订…` 的数值段，缺省段按 0 补齐（`1.2` == `1.2.0`）；
- *  - 预发布/构建元数据（`-beta`、`+build`）只取核心版本比较，忽略其后缀；
- *  - 任一侧无法解析为「点分数字」时，退化为字符串相等判断。
- */
-/** 解析核心数字段；非「点分数字」返回 null（触发字符串回退）。 */
-function parseCore(v) {
-    const core = v.trim().replace(/^[vV]/, "").split(/[-+]/, 1)[0];
-    if (!core)
-        return null;
-    const parts = core.split(".");
-    const nums = [];
-    for (const p of parts) {
-        if (!/^\d+$/.test(p))
-            return null;
-        nums.push(Number(p));
-    }
-    return nums.length > 0 ? nums : null;
-}
-/**
- * 比较 a 与 b：a<b 返回 -1，a>b 返回 1，相等返回 0。
- * 两侧都能解析为点分数字时按数值逐段比较；否则退化为字符串比较。
- */
-export function compareVersions(a, b) {
-    const na = parseCore(a);
-    const nb = parseCore(b);
-    if (na && nb) {
-        const len = Math.max(na.length, nb.length);
-        for (let i = 0; i < len; i++) {
-            const x = na[i] ?? 0;
-            const y = nb[i] ?? 0;
-            if (x < y)
-                return -1;
-            if (x > y)
-                return 1;
-        }
-        return 0;
-    }
-    // 字符串回退：仅区分相等/不等（不臆测大小关系）。
-    const sa = a.trim();
-    const sb = b.trim();
-    if (sa === sb)
-        return 0;
-    return sa < sb ? -1 : 1;
-}
-/**
- * 本地版本是否「落后于」最新版本（即需要更新）。
- *  - 两侧都是合法 semver：latest 数值更大才算过期；
- *  - 无法数值比较时：字符串不相等即视为过期（保守，宁可多更新一次）。
- * 任一侧为空 → 不判过期（缺版本号则不参与更新）。
- */
-export function isOutdated(local, latest) {
-    if (!local || !latest)
-        return false;
-    const na = parseCore(local);
-    const nb = parseCore(latest);
-    if (na && nb)
-        return compareVersions(local, latest) < 0;
-    return local.trim() !== latest.trim();
-}

package/dist/semver.test.js

@@ -1,21 +0,0 @@
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { compareVersions, isOutdated } from "./semver.ts";
-describe("compareVersions", () => {
-    it("数值逐段比较：1.10 > 1.9", () => assert.equal(compareVersions("1.10.0", "1.9.0"), 1));
-    it("缺省段按 0 补齐：1.2 == 1.2.0", () => assert.equal(compareVersions("1.2", "1.2.0"), 0));
-    it("容忍 v 前缀", () => assert.equal(compareVersions("v2.0.0", "2.0.0"), 0));
-    it("a < b", () => assert.equal(compareVersions("1.0.0", "1.0.1"), -1));
-    it("忽略预发布后缀（核心相等）", () => assert.equal(compareVersions("1.0.0-beta", "1.0.0"), 0));
-    it("非数字版本退化为字符串比较", () => assert.equal(compareVersions("abc", "abc"), 0));
-});
-describe("isOutdated", () => {
-    it("本地落后 → true", () => assert.equal(isOutdated("1.0.0", "1.1.0"), true));
-    it("本地更新 → false", () => assert.equal(isOutdated("2.0.0", "1.9.0"), false));
-    it("相等 → false", () => assert.equal(isOutdated("1.2.3", "1.2.3"), false));
-    it("1.9 vs 1.10：应判过期（数值语义）", () => assert.equal(isOutdated("1.9.0", "1.10.0"), true));
-    it("缺本地版本 → 不判过期", () => assert.equal(isOutdated(undefined, "1.0.0"), false));
-    it("缺最新版本 → 不判过期", () => assert.equal(isOutdated("1.0.0", undefined), false));
-    it("非 semver 且不同 → 过期（保守）", () => assert.equal(isOutdated("alpha", "beta"), true));
-    it("带预发布后缀核心相同 → 不过期", () => assert.equal(isOutdated("2026-01", "2026-02"), false));
-});

package/dist/skill-version.js

@@ -1,23 +0,0 @@
-/**
- * 从 SKILL.md 文本中提取版本号（纯正则、不借助任何模型）。
- *
- * 兼容点：
- *  - 键名：英文 `version` / `Version`（大小写不敏感）、中文 `版本号` / `版本`；
- *  - 冒号：半角 `:` 或全角 `：`；
- *  - 取值：去除包裹引号、行尾 ` # 注释`、首尾空白。
- *
- * 范围：在整篇 SKILL.md 内按「单独一行」匹配（frontmatter 在最前，故天然优先命中）。
- * 因要求行首即键名（前面只允许空白），Markdown 标题 `## Version: x`（带 `#` 前缀）不会被误命中。
- * 取不到返回 undefined（该 skill 不参与版本更新）。
- */
-export function parseSkillVersion(content) {
-    const m = /(?:^|\r?\n)[ \t]*(?:version|版本号|版本)[ \t]*[:：][ \t]*(.+)/i.exec(content);
-    if (!m)
-        return undefined;
-    const v = m[1]
-        .replace(/\s+#.*$/, "") // 行尾注释
-        .trim()
-        .replace(/^["']|["']$/g, "") // 包裹引号
-        .trim();
-    return v || undefined;
-}

package/dist/types.js

@@ -1,9 +0,0 @@
-/**
- * 全插件共享的数据类型。
- *
- * 设计要点：
- * - `MatchRule` 是「判别联合」(discriminated union)：用 `type` 字段区分四种匹配策略，
- *   TypeScript 能据此收窄到具体形状，matcher 里按 `rule.type` 分派。
- * - 这些类型同时是「标准配置」的契约：用户平台返回的 JSON 必须符合 `SkillStandardConfig`。
- */
-export {};

package/dist/updater.js

@@ -1,352 +0,0 @@
-/**
- * skill 版本自动更新器。
- *
- * 触发：reconcile 检测到本地某 skill 版本落后于平台最新版本（config.version）后调用。
- * 流程（每个 skill@version 仅下载一次，覆盖其全部 workspace 副本）：
- *   1. POST {platformBaseUrl}/skill_package/pull {skillName, version} → { url }
- *   2. GET url → zip 字节 → 写入临时文件
- *   3. 解压到临时 staging 目录（默认调用系统 unzip）
- *   4. 在 staging 内定位含 SKILL.md 的目录作为源根（兼容包内带或不带顶层目录）
- *   5. 逐个目标目录「直接覆盖、不备份」：先复制到同级临时目录，再删旧、原子 rename 换入，
- *      避免中途失败留下损坏的半成品；不保留 .bak。
- *
- * 安全约束：
- *   - 仅在 autoUpdateSkills===true 且配置了 platformBaseUrl 时执行，默认关闭。
- *   - 任一步失败只 warn 并跳过该 skill，绝不抛、绝不阻塞 reconcile。
- *   - 下载包内必须含 SKILL.md 才会覆盖，否则放弃（防止把目标目录清空成坏内容）。
- */
-import fs from "node:fs/promises";
-import path from "node:path";
-import os from "node:os";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { randomUUID, createHash } from "node:crypto";
-import { parseSkillVersion } from "./skill-version.ts";
-const execFileAsync = promisify(execFile);
-/**
- * 同一 skill@version 的更新尝试冷却期。
- * 防止「下载包版本号与平台 latestVersion 不一致 / 非 semver 版本永不相等」等情况下，
- * 每 3 分钟一轮 reconcile 反复下载覆盖。成功更新会改变本地版本从而不再判过期，故冷却只影响失败/不一致场景。
- */
-const ATTEMPT_COOLDOWN_MS = 30 * 60 * 1000;
-/**
- * 轻量「身份哈希」：name + code + version。约定 name==code（SKILL.md 的 name 即 skillCode），
- * 故按 `code code version`（空格分隔）计算 sha256。与服务端 skillIdentityHash 必须保持一致。
- * 仅做身份/版本一致性校验，不做整包字节哈希。
- */
-function skillIdentityHash(code, version) {
-    return createHash("sha256").update(`${code} ${code} ${version}`).digest("hex");
-}
-/** 默认解压：系统 unzip -o -q（覆盖、静默）。 */
-async function systemUnzip(zipPath, destDir) {
-    await fs.mkdir(destDir, { recursive: true });
-    await execFileAsync("unzip", ["-o", "-q", zipPath, "-d", destDir]);
-}
-export class SkillUpdater {
-    getConfig;
-    fetchImpl;
-    unzip;
-    tmpDir;
-    /** 冷却期状态持久化文件路径。 */
-    cooldownStatePath;
-    /** skill@version → 上次尝试时间戳，用于冷却，避免重复下载覆盖。 */
-    lastAttempt = new Map();
-    constructor(opts) {
-        this.getConfig = opts.getConfig;
-        this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
-        this.unzip = opts.unzip ?? systemUnzip;
-        this.tmpDir = opts.tmpDir ?? os.tmpdir();
-        this.cooldownStatePath = opts.cooldownStatePath;
-        this.loadCooldown(); // 同步读取，启动早期就需要用到冷却期
-    }
-    get isDebug() {
-        return this.getConfig().debugLogging !== false;
-    }
-    debug(...args) {
-        if (this.isDebug)
-            console.log("[skill-logger-plugin/updater]", ...args);
-    }
-    /** 从文件同步加载冷却期状态到内存Map。文件不存在或解析失败时静默跳过。 */
-    loadCooldown() {
-        if (!this.cooldownStatePath)
-            return;
-        try {
-            const raw = fs.readFileSync(this.cooldownStatePath, "utf-8");
-            const obj = JSON.parse(raw);
-            for (const [k, v] of Object.entries(obj)) {
-                if (typeof v === "number" && Number.isFinite(v)) {
-                    this.lastAttempt.set(k, v);
-                }
-            }
-            this.debug(`冷却期状态已从文件恢复，共 ${this.lastAttempt.size} 条`);
-        }
-        catch {
-            // 文件不存在或解析失败 → 用空Map，插件继续正常工作
-        }
-    }
-    /** 将内存中的冷却期状态写入文件。写入失败时静默跳过，不影响主流程。 */
-    async persistCooldown() {
-        if (!this.cooldownStatePath)
-            return;
-        try {
-            const obj = {};
-            for (const [k, v] of this.lastAttempt) {
-                obj[k] = v;
-            }
-            await fs.writeFile(this.cooldownStatePath, JSON.stringify(obj), "utf-8");
-        }
-        catch {
-            // 写入失败不影响主流程，下次会继续尝试
-        }
-    }
-    /** 对一批落后副本执行更新。按 skill@version 去重下载，覆盖各自的全部目标目录。 */
-    async applyUpdates(outdated) {
-        const cfg = this.getConfig();
-        if (cfg.autoUpdateSkills === false)
-            return; // 默认开启，仅显式 false 关闭
-        if (!cfg.platformBaseUrl)
-            return; // 无平台地址无法下载
-        if (outdated.length === 0)
-            return;
-        const groups = new Map();
-        for (const o of outdated) {
-            const key = `${o.skillName}@${o.latestVersion}`;
-            let g = groups.get(key);
-            if (!g) {
-                g = { skillName: o.skillName, version: o.latestVersion, targets: [] };
-                groups.set(key, g);
-            }
-            if (!g.targets.includes(o.rootDir))
-                g.targets.push(o.rootDir);
-        }
-        for (const g of groups.values()) {
-            const key = `${g.skillName}@${g.version}`;
-            const last = this.lastAttempt.get(key);
-            if (last !== undefined && Date.now() - last < ATTEMPT_COOLDOWN_MS) {
-                this.debug(`跳过 ${key}：距上次尝试不足冷却期（防重复下载覆盖）`);
-                continue;
-            }
-            this.lastAttempt.set(key, Date.now()); // 不论成败都记，失败也按冷却退避，避免每 3 分钟重试
-            await this.persistCooldown(); // 持久化到文件，重启后冷却期不丢失
-            try {
-                await this.updateOne(g.skillName, g.version, g.targets);
-            }
-            catch (err) {
-                console.warn(`[skill-logger-plugin] 自动更新 ${key} 异常`, err);
-            }
-        }
-    }
-    async updateOne(skillName, version, targets) {
-        const dl = await this.fetchDownloadUrl(skillName, version);
-        if (!dl?.url)
-            return;
-        const work = path.join(this.tmpDir, `slp-update-${randomUUID()}`);
-        await fs.mkdir(work, { recursive: true });
-        try {
-            const zipPath = path.join(work, "pkg.zip");
-            const res = await this.fetchImpl(dl.url);
-            if (!res.ok) {
-                console.warn(`[skill-logger-plugin] 下载 ${skillName}@${version} 失败 HTTP`, res.status);
-                return;
-            }
-            const buf = Buffer.from(await res.arrayBuffer());
-            await fs.writeFile(zipPath, buf);
-            const staging = path.join(work, "staging");
-            await this.unzip(zipPath, staging);
-            const srcRoot = await this.locateSkillRoot(staging, 0);
-            if (!srcRoot) {
-                console.warn(`[skill-logger-plugin] ${skillName}@${version} 下载包内未找到 SKILL.md，放弃覆盖`);
-                return;
-            }
-            // [兼容处理] 缺少 .meta.json 时主动补齐
-            const metaPath = path.join(srcRoot, ".meta.json");
-            if (!(await this.exists(metaPath))) {
-                this.debug(`[skill-logger-plugin] 为 ${skillName}@${version} 自动生成 .meta.json`);
-                await fs.writeFile(metaPath, JSON.stringify({
-                    ownerId: 'CMS_COMPAT',
-                    slug: skillName,
-                    version: version,
-                    publishedAt: Date.now()
-                }, null, 2));
-            }
-            // 守卫：下载包的 SKILL.md 必须能解析出版本号，否则不做覆盖（服务端要求：无版本号不更新）。
-            let packageVersion;
-            try {
-                const newSkillMd = await fs.readFile(path.join(srcRoot, "SKILL.md"), "utf-8");
-                packageVersion = parseSkillVersion(newSkillMd);
-            }
-            catch {
-                console.warn(`[skill-logger-plugin] ${skillName}@${version} 读取下载包 SKILL.md 失败，放弃覆盖`);
-                return;
-            }
-            if (!packageVersion) {
-                console.warn(`[skill-logger-plugin] ${skillName}@${version} 下载包 SKILL.md 无版本号，放弃覆盖`);
-                return;
-            }
-            for (const target of targets) {
-                try {
-                    await this.replaceDir(srcRoot, target);
-                    this.debug(`已更新 ${skillName} → ${version} @ ${target}`);
-                }
-                catch (err) {
-                    console.warn(`[skill-logger-plugin] 覆盖 ${skillName} 到 ${target} 失败`, err);
-                }
-            }
-        }
-        finally {
-            await fs.rm(work, { recursive: true, force: true });
-        }
-    }
-    /** POST 下载接口取包 URL。返回 undefined 表示拿不到（调用方放弃本次更新）。 */
-    async fetchDownloadUrl(skillName, version) {
-        const cfg = this.getConfig();
-        const endpoint = cfg.platformBaseUrl.replace(/\/$/, "") + "/skill_package/pull";
-        const headers = { "Content-Type": "application/json" };
-        if (cfg.authToken)
-            headers.Authorization = cfg.authToken;
-        const res = await this.fetchImpl(endpoint, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({ skillName, version }),
-        });
-        if (!res.ok) {
-            console.warn(`[skill-logger-plugin] 取下载地址 ${skillName}@${version} 失败 HTTP`, res.status);
-            return undefined;
-        }
-        const data = (await res.json());
-        const url = typeof data?.url === "string" ? data.url : typeof data?.downloadUrl === "string" ? data.downloadUrl : undefined;
-        const resolvedVersion = typeof data?.version === "string" ? data.version : undefined;
-        if (!url)
-            return undefined;
-        return { url, version: resolvedVersion };
-    }
-    /** 在解压目录里定位含 SKILL.md 的目录（兼容包内是否带顶层目录）。深度上限 2。 */
-    async locateSkillRoot(dir, depth) {
-        if (depth > 2)
-            return undefined;
-        let entries;
-        try {
-            entries = await fs.readdir(dir, { withFileTypes: true });
-        }
-        catch {
-            return undefined;
-        }
-        if (entries.some((e) => e.isFile() && e.name === "SKILL.md"))
-            return dir;
-        for (const e of entries) {
-            if (e.isDirectory()) {
-                const found = await this.locateSkillRoot(path.join(dir, e.name), depth + 1);
-                if (found)
-                    return found;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * 直接覆盖、不备份，但保证「不丢数据」：
-     *   先把新内容暂存到同级临时目录 → 旧目录改名挪开 → 新内容 rename 换入 → 删掉挪开的旧目录。
-     * 换入失败时把旧目录还原，避免目标被清空。过程中的临时/旧目录都是隐藏且即时清理，不保留 .bak。
-     */
-    async replaceDir(src, target) {
-        const parent = path.dirname(target);
-        await fs.mkdir(parent, { recursive: true });
-        const tag = `${Date.now()}-${randomUUID().slice(0, 8)}`;
-        const stage = path.join(parent, `.${path.basename(target)}.new-${tag}`);
-        const old = path.join(parent, `.${path.basename(target)}.old-${tag}`);
-        await fs.rm(stage, { recursive: true, force: true });
-        await fs.cp(src, stage, { recursive: true });
-        const hadTarget = await this.exists(target);
-        if (hadTarget)
-            await fs.rename(target, old); // 旧目录先挪开（仍完整保留，便于回滚）
-        try {
-            await fs.rename(stage, target); // 新内容换入
-        }
-        catch (err) {
-            // 换入失败：还原旧目录，清理暂存，确保目标不丢
-            if (hadTarget)
-                await fs.rename(old, target).catch(() => { });
-            await fs.rm(stage, { recursive: true, force: true }).catch(() => { });
-            throw err;
-        }
-        await fs.rm(old, { recursive: true, force: true }).catch(() => { }); // 成功后清理，不留备份
-    }
-    async exists(p) {
-        try {
-            await fs.access(p);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 手动下发安装/更新指令 (供沙盒 HTTP Proxy 与星型架构中控使用)
-     */
-    async manualInstall(options) {
-        const { code, force, targetDir } = options;
-        let { url, version } = options;
-        if (!url) {
-            // 若没有直接传入 ZIP 的 URL，向平台索取该 skill 的 latest 下载地址
-            const dl = await this.fetchDownloadUrl(code, version || "latest");
-            if (!dl?.url) {
-                return { success: false, message: `无法获取技能 ${code} 的下载地址` };
-            }
-            url = dl.url;
-            version = dl.version || version;
-        }
-        const targetSkillPath = path.join(targetDir, code);
-        // 如果非强制覆盖，且目标已经存在，则直接返回
-        if (!force && await this.exists(targetSkillPath)) {
-            return { success: false, message: `技能 ${code} 已存在于目标目录` };
-        }
-        const work = path.join(this.tmpDir, `slp-manual-${randomUUID()}`);
-        await fs.mkdir(work, { recursive: true });
-        try {
-            // 1. 下载 ZIP
-            const zipPath = path.join(work, "pkg.zip");
-            const res = await this.fetchImpl(url);
-            if (!res.ok) {
-                return { success: false, message: `下载失败: HTTP ${res.status}` };
-            }
-            const buf = Buffer.from(await res.arrayBuffer());
-            await fs.writeFile(zipPath, buf);
-            // 2. 调用系统解压工具 unzip
-            const staging = path.join(work, "staging");
-            await this.unzip(zipPath, staging);
-            // 3. 递归寻找真正的技能根目录（包含 SKILL.md 的一层）
-            const srcRoot = await this.locateSkillRoot(staging, 0);
-            if (!srcRoot) {
-                return { success: false, message: `下载包内未找到 SKILL.md，非法的技能包结构` };
-            }
-            // [兼容处理] 缺少 .meta.json 时主动补齐
-            const metaPath = path.join(srcRoot, ".meta.json");
-            if (!(await this.exists(metaPath))) {
-                let parsedVersion = version || "unknown";
-                if (!version) {
-                    try {
-                        const newSkillMd = await fs.readFile(path.join(srcRoot, "SKILL.md"), "utf-8");
-                        parsedVersion = parseSkillVersion(newSkillMd) || "unknown";
-                    }
-                    catch { }
-                }
-                this.debug(`[skill-logger-plugin] 为手动安装的 ${code}@${parsedVersion} 自动生成 .meta.json`);
-                await fs.writeFile(metaPath, JSON.stringify({
-                    ownerId: 'CMS_COMPAT',
-                    slug: code,
-                    version: parsedVersion,
-                    publishedAt: Date.now()
-                }, null, 2));
-            }
-            // 4. 原子级无缝替换目录 (先暂存，再 rename)
-            await this.replaceDir(srcRoot, targetSkillPath);
-            return { success: true, message: `技能 ${code} 安装/更新成功` };
-        }
-        catch (err) {
-            return { success: false, message: `执行出错: ${err.message}` };
-        }
-        finally {
-            // 清理临时工作区
-            await fs.rm(work, { recursive: true, force: true }).catch(() => { });
-        }
-    }
-}