@spzhongwin/skill-logger-plugin 1.0.2 → 1.0.3

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/index.ts
-import fs6 from "node:fs";
-import path8 from "node:path";
+import fs7 from "node:fs";
+import path9 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import os4 from "node:os";
 
@@ -101,17 +101,38 @@ var ActiveSkills = class {
 };
 
 // src/updater.ts
-import fs2 from "node:fs/promises";
+import fs3 from "node:fs/promises";
 import fsSync from "node:fs";
-import path2 from "node:path";
+import path3 from "node:path";
 import os2 from "node:os";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { randomUUID, createHash } from "node:crypto";
 
 // src/skill-version.ts
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+async function readSkillVersion2(rootDir, skillMdContent) {
+  try {
+    const metaPath = path2.join(rootDir, ".meta.json");
+    const metaContent = await fs2.readFile(metaPath, "utf-8");
+    const meta = JSON.parse(metaContent);
+    if (meta && typeof meta.version === "string" && meta.version.trim() && meta.version !== "unknown") {
+      return meta.version.trim();
+    }
+  } catch {
+  }
+  if (!skillMdContent) {
+    try {
+      skillMdContent = await fs2.readFile(path2.join(rootDir, "SKILL.md"), "utf-8");
+    } catch {
+      return void 0;
+    }
+  }
+  return parseSkillVersion(skillMdContent);
+}
 function parseSkillVersion(content) {
-  const m = /(?:^|\r?\n)[ \t]*(?:version|版本号|版本)[ \t]*[:：][ \t]*(.+)/i.exec(content);
+  const m = /(?:^|\r?\n)[ \t]*(?:version|当前版本号|当前版本|版本号|版本)[ \t]*[:：][ \t]*(.+)/i.exec(content);
   if (!m) return void 0;
   const v = m[1].replace(/\s+#.*$/, "").trim().replace(/^["']|["']$/g, "").trim();
   return v || void 0;
@@ -121,7 +142,7 @@ function parseSkillVersion(content) {
 var execFileAsync = promisify(execFile);
 var ATTEMPT_COOLDOWN_MS = 30 * 60 * 1e3;
 async function systemUnzip(zipPath, destDir) {
-  await fs2.mkdir(destDir, { recursive: true });
+  await fs3.mkdir(destDir, { recursive: true });
   await execFileAsync("unzip", ["-o", "-q", zipPath, "-d", destDir]);
 }
 var SkillUpdater = class {
@@ -170,7 +191,7 @@ var SkillUpdater = class {
       for (const [k, v] of this.lastAttempt) {
         obj[k] = v;
       }
-      await fs2.writeFile(this.cooldownStatePath, JSON.stringify(obj), "utf-8");
+      await fs3.writeFile(this.cooldownStatePath, JSON.stringify(obj), "utf-8");
     } catch {
     }
   }
@@ -209,46 +230,45 @@ var SkillUpdater = class {
   async updateOne(skillName, version, targets) {
     const dl = await this.fetchDownloadUrl(skillName, version);
     if (!dl?.url) return;
-    const work = path2.join(this.tmpDir, `slp-update-${randomUUID()}`);
-    await fs2.mkdir(work, { recursive: true });
+    const work = path3.join(this.tmpDir, `slp-update-${randomUUID()}`);
+    await fs3.mkdir(work, { recursive: true });
     try {
-      const zipPath = path2.join(work, "pkg.zip");
+      const zipPath = path3.join(work, "pkg.zip");
       const res = await this.fetchImpl(dl.url);
       if (!res.ok) {
         console.warn(`[skill-logger-plugin] \u4E0B\u8F7D ${skillName}@${version} \u5931\u8D25 HTTP`, res.status);
         return;
       }
       const buf = Buffer.from(await res.arrayBuffer());
-      await fs2.writeFile(zipPath, buf);
-      const staging = path2.join(work, "staging");
+      await fs3.writeFile(zipPath, buf);
+      const staging = path3.join(work, "staging");
       await this.unzip(zipPath, staging);
       const srcRoot = await this.locateSkillRoot(staging, 0);
       if (!srcRoot) {
         console.warn(`[skill-logger-plugin] ${skillName}@${version} \u4E0B\u8F7D\u5305\u5185\u672A\u627E\u5230 SKILL.md\uFF0C\u653E\u5F03\u8986\u76D6`);
         return;
       }
-      const metaPath = path2.join(srcRoot, ".meta.json");
-      if (!await this.exists(metaPath)) {
-        this.debug(`[skill-logger-plugin] \u4E3A ${skillName}@${version} \u81EA\u52A8\u751F\u6210 .meta.json`);
-        await fs2.writeFile(metaPath, JSON.stringify({
-          ownerId: "CMS_COMPAT",
-          slug: skillName,
-          version,
-          publishedAt: Date.now()
-        }, null, 2));
-      }
       let packageVersion;
       try {
-        const newSkillMd = await fs2.readFile(path2.join(srcRoot, "SKILL.md"), "utf-8");
-        packageVersion = parseSkillVersion(newSkillMd);
+        packageVersion = await readSkillVersion(srcRoot);
       } catch {
-        console.warn(`[skill-logger-plugin] ${skillName}@${version} \u8BFB\u53D6\u4E0B\u8F7D\u5305 SKILL.md \u5931\u8D25\uFF0C\u653E\u5F03\u8986\u76D6`);
+        console.warn(`[skill-logger-plugin] ${skillName}@${version} \u8BFB\u53D6\u4E0B\u8F7D\u5305\u7248\u672C\u53F7\u5931\u8D25\uFF0C\u653E\u5F03\u8986\u76D6`);
         return;
       }
       if (!packageVersion) {
-        console.warn(`[skill-logger-plugin] ${skillName}@${version} \u4E0B\u8F7D\u5305 SKILL.md \u65E0\u7248\u672C\u53F7\uFF0C\u653E\u5F03\u8986\u76D6`);
+        console.warn(`[skill-logger-plugin] ${skillName}@${version} \u4E0B\u8F7D\u5305\u65E0\u7248\u672C\u53F7\uFF0C\u653E\u5F03\u8986\u76D6`);
         return;
       }
+      const metaPath = path3.join(srcRoot, ".meta.json");
+      if (!await this.exists(metaPath)) {
+        this.debug(`[skill-logger-plugin] \u4E3A ${skillName}@${version} \u81EA\u52A8\u751F\u6210 .meta.json`);
+        await fs3.writeFile(metaPath, JSON.stringify({
+          ownerId: "CMS_COMPAT",
+          slug: skillName,
+          version: packageVersion,
+          publishedAt: Date.now()
+        }, null, 2));
+      }
       for (const target of targets) {
         try {
           await this.replaceDir(srcRoot, target);
@@ -258,7 +278,7 @@ var SkillUpdater = class {
         }
       }
     } finally {
-      await fs2.rm(work, { recursive: true, force: true });
+      await fs3.rm(work, { recursive: true, force: true });
     }
   }
   /** POST 下载接口取包 URL。返回 undefined 表示拿不到（调用方放弃本次更新）。 */
@@ -287,14 +307,14 @@ var SkillUpdater = class {
     if (depth > 2) return void 0;
     let entries;
     try {
-      entries = await fs2.readdir(dir, { withFileTypes: true });
+      entries = await fs3.readdir(dir, { withFileTypes: true });
     } catch {
       return void 0;
     }
     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(path2.join(dir, e.name), depth + 1);
+        const found = await this.locateSkillRoot(path3.join(dir, e.name), depth + 1);
         if (found) return found;
       }
     }
@@ -306,30 +326,30 @@ var SkillUpdater = class {
    * 换入失败时把旧目录还原，避免目标被清空。过程中的临时/旧目录都是隐藏且即时清理，不保留 .bak。
    */
   async replaceDir(src, target) {
-    const parent = path2.dirname(target);
-    await fs2.mkdir(parent, { recursive: true });
+    const parent = path3.dirname(target);
+    await fs3.mkdir(parent, { recursive: true });
     const tag = `${Date.now()}-${randomUUID().slice(0, 8)}`;
-    const stage = path2.join(parent, `.${path2.basename(target)}.new-${tag}`);
-    const old = path2.join(parent, `.${path2.basename(target)}.old-${tag}`);
-    await fs2.rm(stage, { recursive: true, force: true });
-    await fs2.cp(src, stage, { recursive: true });
+    const stage = path3.join(parent, `.${path3.basename(target)}.new-${tag}`);
+    const old = path3.join(parent, `.${path3.basename(target)}.old-${tag}`);
+    await fs3.rm(stage, { recursive: true, force: true });
+    await fs3.cp(src, stage, { recursive: true });
     const hadTarget = await this.exists(target);
-    if (hadTarget) await fs2.rename(target, old);
+    if (hadTarget) await fs3.rename(target, old);
     try {
-      await fs2.rename(stage, target);
+      await fs3.rename(stage, target);
     } catch (err) {
-      if (hadTarget) await fs2.rename(old, target).catch(() => {
+      if (hadTarget) await fs3.rename(old, target).catch(() => {
       });
-      await fs2.rm(stage, { recursive: true, force: true }).catch(() => {
+      await fs3.rm(stage, { recursive: true, force: true }).catch(() => {
       });
       throw err;
     }
-    await fs2.rm(old, { recursive: true, force: true }).catch(() => {
+    await fs3.rm(old, { recursive: true, force: true }).catch(() => {
     });
   }
   async exists(p) {
     try {
-      await fs2.access(p);
+      await fs3.access(p);
       return true;
     } catch {
       return false;
@@ -349,38 +369,38 @@ var SkillUpdater = class {
       url = dl.url;
       version = dl.version || version;
     }
-    const targetSkillPath = path2.join(targetDir, code);
+    const targetSkillPath = path3.join(targetDir, code);
     if (!force && await this.exists(targetSkillPath)) {
       return { success: false, message: `\u6280\u80FD ${code} \u5DF2\u5B58\u5728\u4E8E\u76EE\u6807\u76EE\u5F55` };
     }
-    const work = path2.join(this.tmpDir, `slp-manual-${randomUUID()}`);
-    await fs2.mkdir(work, { recursive: true });
+    const work = path3.join(this.tmpDir, `slp-manual-${randomUUID()}`);
+    await fs3.mkdir(work, { recursive: true });
     try {
-      const zipPath = path2.join(work, "pkg.zip");
+      const zipPath = path3.join(work, "pkg.zip");
       const res = await this.fetchImpl(url);
       if (!res.ok) {
         return { success: false, message: `\u4E0B\u8F7D\u5931\u8D25: HTTP ${res.status}` };
       }
       const buf = Buffer.from(await res.arrayBuffer());
-      await fs2.writeFile(zipPath, buf);
-      const staging = path2.join(work, "staging");
+      await fs3.writeFile(zipPath, buf);
+      const staging = path3.join(work, "staging");
       await this.unzip(zipPath, staging);
       const srcRoot = await this.locateSkillRoot(staging, 0);
       if (!srcRoot) {
         return { success: false, message: `\u4E0B\u8F7D\u5305\u5185\u672A\u627E\u5230 SKILL.md\uFF0C\u975E\u6CD5\u7684\u6280\u80FD\u5305\u7ED3\u6784` };
       }
-      const metaPath = path2.join(srcRoot, ".meta.json");
+      const metaPath = path3.join(srcRoot, ".meta.json");
       if (!await this.exists(metaPath)) {
         let parsedVersion = version || "unknown";
         if (!version) {
           try {
-            const newSkillMd = await fs2.readFile(path2.join(srcRoot, "SKILL.md"), "utf-8");
+            const newSkillMd = await fs3.readFile(path3.join(srcRoot, "SKILL.md"), "utf-8");
             parsedVersion = parseSkillVersion(newSkillMd) || "unknown";
           } catch {
           }
         }
         this.debug(`[skill-logger-plugin] \u4E3A\u624B\u52A8\u5B89\u88C5\u7684 ${code}@${parsedVersion} \u81EA\u52A8\u751F\u6210 .meta.json`);
-        await fs2.writeFile(metaPath, JSON.stringify({
+        await fs3.writeFile(metaPath, JSON.stringify({
           ownerId: "CMS_COMPAT",
           slug: code,
           version: parsedVersion,
@@ -392,19 +412,19 @@ var SkillUpdater = class {
     } catch (err) {
       return { success: false, message: `\u6267\u884C\u51FA\u9519: ${err.message}` };
     } finally {
-      await fs2.rm(work, { recursive: true, force: true }).catch(() => {
+      await fs3.rm(work, { recursive: true, force: true }).catch(() => {
       });
     }
   }
 };
 
 // src/config-sync.ts
-import fs3 from "node:fs/promises";
-import path4 from "node:path";
+import fs4 from "node:fs/promises";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/matcher.ts
-import path3 from "node:path";
+import path4 from "node:path";
 var INTERPRETERS = /* @__PURE__ */ new Set([
   "python",
   "python3",
@@ -452,7 +472,7 @@ function buildIndex(configs) {
       };
       switch (fn.match.type) {
         case "script":
-          pushBucket(index.scriptByBasename, path3.basename(fn.match.script), indexed);
+          pushBucket(index.scriptByBasename, path4.basename(fn.match.script), indexed);
           break;
         case "command":
           pushBucket(index.commandByHead, fn.match.command, indexed);
@@ -536,7 +556,7 @@ function commandHead(tokens) {
   for (let i = 0; i < tokens.length; i++) {
     const t = tokens[i];
     if (/^[A-Za-z_][\w]*=/.test(t)) continue;
-    const base = path3.basename(t);
+    const base = path4.basename(t);
     if (INTERPRETERS.has(base)) continue;
     return base;
   }
@@ -640,7 +660,7 @@ function match(call, activeSkills, index) {
     const tokens = tokenize(command);
     const flags = parseFlags(tokens);
     for (const tok of tokens) {
-      const fns = index.scriptByBasename.get(path3.basename(tok));
+      const fns = index.scriptByBasename.get(path4.basename(tok));
       if (!fns) continue;
       for (const f of fns) {
         const rule = f.rule;
@@ -818,7 +838,7 @@ var ConfigSync = class {
   /** 从磁盘加载已缓存的同步状态并重建索引（gateway 启动时调一次）。 */
   async load() {
     try {
-      const raw = await fs3.readFile(this.paths.syncStatePath, "utf-8");
+      const raw = await fs4.readFile(this.paths.syncStatePath, "utf-8");
       const state = JSON.parse(raw);
       if (state.skills) {
         for (const [name, entry] of Object.entries(state.skills)) {
@@ -860,16 +880,16 @@ var ConfigSync = class {
       if (depth > MAX_SCAN_DEPTH) return;
       let entries;
       try {
-        entries = await fs3.readdir(dir, { withFileTypes: true });
+        entries = await fs4.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
       for (const e of entries) {
         if (e.isDirectory()) {
           if (SKIP_DIRS.has(e.name)) continue;
-          await walk(path4.join(dir, e.name), depth + 1);
+          await walk(path5.join(dir, e.name), depth + 1);
         } else if (e.name === "SKILL.md") {
-          const skillMd = path4.join(dir, e.name);
+          const skillMd = path5.join(dir, e.name);
           const skill = await this.readSkill(dir, skillMd);
           if (skill) {
             out.push(skill);
@@ -912,10 +932,10 @@ var ConfigSync = class {
   }
   async readSkill(rootDir, skillMdPath) {
     try {
-      const content = await fs3.readFile(skillMdPath, "utf-8");
+      const content = await fs4.readFile(skillMdPath, "utf-8");
       const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1] ?? "";
-      const name = /(^|\n)name:\s*(.+)/.exec(fm)?.[2]?.trim() || path4.basename(rootDir);
-      const version = parseSkillVersion(content);
+      const name = /(^|\n)name:\s*(.+)/.exec(fm)?.[2]?.trim() || path5.basename(rootDir);
+      const version = await readSkillVersion2(rootDir, content);
       const signature = await this.computeSignature(rootDir, skillMdPath, version);
       return { name, version, rootDir, signature };
     } catch {
@@ -926,16 +946,16 @@ var ConfigSync = class {
   async computeSignature(rootDir, skillMdPath, version) {
     const parts = [version ?? ""];
     try {
-      const st = await fs3.stat(skillMdPath);
+      const st = await fs4.stat(skillMdPath);
       parts.push(`md:${st.mtimeMs}:${st.size}`);
     } catch {
     }
     try {
-      const scriptsDir = path4.join(rootDir, "scripts");
-      const entries = await fs3.readdir(scriptsDir, { withFileTypes: true });
+      const scriptsDir = path5.join(rootDir, "scripts");
+      const entries = await fs4.readdir(scriptsDir, { withFileTypes: true });
       for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         if (!e.isFile()) continue;
-        const st = await fs3.stat(path4.join(scriptsDir, e.name));
+        const st = await fs4.stat(path5.join(scriptsDir, e.name));
         parts.push(`s:${e.name}:${st.mtimeMs}:${st.size}`);
       }
     } catch {
@@ -1018,7 +1038,7 @@ var ConfigSync = class {
   /** 懒触发：仅检查某个被触发的 skill，缺配置/签名变才拉。`ident` 可为规范名或目录名。 */
   async lazyCheck(ident) {
     try {
-      const find = (list) => list.find((x) => x.name === ident || path4.basename(x.rootDir) === ident);
+      const find = (list) => list.find((x) => x.name === ident || path5.basename(x.rootDir) === ident);
       let s = find(await this.scanInstalledSkillsCached());
       if (!s) {
         const fresh = await this.scanInstalledSkills();
@@ -1094,8 +1114,8 @@ var ConfigSync = class {
   async loadSampleConfigs() {
     if (this.sampleConfigs) return this.sampleConfigs;
     try {
-      const here = path4.dirname(fileURLToPath(import.meta.url));
-      const raw = await fs3.readFile(path4.join(here, "sample-config.json"), "utf-8");
+      const here = path5.dirname(fileURLToPath(import.meta.url));
+      const raw = await fs4.readFile(path5.join(here, "sample-config.json"), "utf-8");
       this.sampleConfigs = JSON.parse(raw).configs;
     } catch {
       this.sampleConfigs = [];
@@ -1117,10 +1137,10 @@ var ConfigSync = class {
       for (const [name, copies] of this.installations) {
         state.installations[name] = copies.map((c) => ({ rootDir: c.rootDir, version: c.version }));
       }
-      await fs3.mkdir(path4.dirname(this.paths.syncStatePath), { recursive: true });
+      await fs4.mkdir(path5.dirname(this.paths.syncStatePath), { recursive: true });
       const tmp = `${this.paths.syncStatePath}.tmp-${process.pid}-${Date.now()}`;
-      await fs3.writeFile(tmp, JSON.stringify(state));
-      await fs3.rename(tmp, this.paths.syncStatePath);
+      await fs4.writeFile(tmp, JSON.stringify(state));
+      await fs4.rename(tmp, this.paths.syncStatePath);
     } catch (err) {
       console.warn("[skill-logger-plugin] \u6301\u4E45\u5316\u540C\u6B65\u72B6\u6001\u5931\u8D25", err);
     }
@@ -1128,8 +1148,8 @@ var ConfigSync = class {
 };
 
 // src/reporter.ts
-import fs4 from "node:fs/promises";
-import path5 from "node:path";
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
 
 // src/identity.ts
 import os3 from "node:os";
@@ -1198,9 +1218,9 @@ var Reporter = class {
       const ts = (/* @__PURE__ */ new Date()).toISOString();
       const logLine = `[${ts}] [${level}] [skill-logger-plugin] ${msg}
 `;
-      const logDir = path5.dirname(this.paths.eventsLogPath);
-      await fs4.mkdir(logDir, { recursive: true });
-      await fs4.appendFile(path5.join(logDir, "skill-logger.err.log"), logLine);
+      const logDir = path6.dirname(this.paths.eventsLogPath);
+      await fs5.mkdir(logDir, { recursive: true });
+      await fs5.appendFile(path6.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") {
@@ -1233,8 +1253,8 @@ var Reporter = class {
       } catch {
         return;
       }
-      await fs4.mkdir(path5.dirname(this.paths.eventsLogPath), { recursive: true });
-      await fs4.appendFile(this.paths.eventsLogPath, line + "\n");
+      await fs5.mkdir(path6.dirname(this.paths.eventsLogPath), { recursive: true });
+      await fs5.appendFile(this.paths.eventsLogPath, line + "\n");
     } catch (err) {
       void this.writeFallbackLog("ERROR", "\u5199\u4E8B\u4EF6\u65E5\u5FD7\u5931\u8D25", this.paths.eventsLogPath, err);
     }
@@ -1304,19 +1324,19 @@ var Reporter = class {
         void this.writeFallbackLog("WARN", "flush skipped: reportBaseUrl \u6CA1\u6709\u914D\u7F6E\uFF01\u8BF7\u68C0\u67E5 openclaw.json \u63D2\u4EF6\u914D\u7F6E\u662F\u5426\u6B63\u786E\u52A0\u8F7D\u3002");
         return;
       }
-      const logDir = path5.dirname(this.paths.eventsLogPath);
+      const logDir = path6.dirname(this.paths.eventsLogPath);
       try {
-        await fs4.access(this.paths.eventsLogPath);
+        await fs5.access(this.paths.eventsLogPath);
         const timestamp = Date.now();
-        const rotatedPath = path5.join(logDir, `events.${timestamp}.jsonl`);
-        await fs4.rename(this.paths.eventsLogPath, rotatedPath);
-        this.debug(`Rotated active log to ${path5.basename(rotatedPath)}`);
+        const rotatedPath = path6.join(logDir, `events.${timestamp}.jsonl`);
+        await fs5.rename(this.paths.eventsLogPath, rotatedPath);
+        this.debug(`Rotated active log to ${path6.basename(rotatedPath)}`);
       } catch {
       }
       let files = [];
       try {
-        const dirEntries = await fs4.readdir(logDir);
-        files = dirEntries.filter((f) => f.startsWith("events.") && f.endsWith(".jsonl") && f !== "events.jsonl").map((f) => path5.join(logDir, f));
+        const dirEntries = await fs5.readdir(logDir);
+        files = dirEntries.filter((f) => f.startsWith("events.") && f.endsWith(".jsonl") && f !== "events.jsonl").map((f) => path6.join(logDir, f));
       } catch {
         return;
       }
@@ -1329,10 +1349,10 @@ var Reporter = class {
       const url = config.reportBaseUrl.replace(/\/$/, "") + "/skill_report/batch";
       for (const filePath of files) {
         try {
-          const content = await fs4.readFile(filePath, "utf-8");
+          const content = await fs5.readFile(filePath, "utf-8");
           const lines = this.linesOf(content);
           if (lines.length === 0) {
-            await fs4.unlink(filePath);
+            await fs5.unlink(filePath);
             continue;
           }
           let cursor = 0;
@@ -1362,7 +1382,7 @@ var Reporter = class {
             const res = await this.fetchImpl(url, { method: "POST", headers, body });
             if (!res.ok) {
               const errBody = await res.text().catch(() => "\u65E0\u6CD5\u8BFB\u53D6\u54CD\u5E94\u4F53");
-              await this.writeFallbackLog("ERROR", `\u6279\u91CF\u4E0A\u62A5\u5931\u8D25 (\u6587\u4EF6 ${path5.basename(filePath)}), HTTP`, res.status, "\u670D\u52A1\u7AEF\u8FD4\u56DE\u4FE1\u606F:", errBody);
+              await this.writeFallbackLog("ERROR", `\u6279\u91CF\u4E0A\u62A5\u5931\u8D25 (\u6587\u4EF6 ${path6.basename(filePath)}), HTTP`, res.status, "\u670D\u52A1\u7AEF\u8FD4\u56DE\u4FE1\u606F:", errBody);
               if (res.status === 400 || res.status === 413 || res.status === 422) {
                 await this.writeFallbackLog("WARN", `\u62A5\u6587\u88AB\u670D\u52A1\u5668\u6C38\u4E45\u62D2\u7EDD\uFF0C\u4E22\u5F03\u8BE5\u6279\u6B21\u4EE5\u91CA\u653E\u961F\u5217`);
                 cursor += slice.length;
@@ -1371,17 +1391,17 @@ var Reporter = class {
               allSuccess = false;
               break;
             }
-            this.debug(`Successfully reported batch of ${events.length} events from ${path5.basename(filePath)}`);
+            this.debug(`Successfully reported batch of ${events.length} events from ${path6.basename(filePath)}`);
             cursor += slice.length;
           }
           if (allSuccess) {
-            await fs4.unlink(filePath);
-            this.debug(`Deleted fully processed file: ${path5.basename(filePath)}`);
+            await fs5.unlink(filePath);
+            this.debug(`Deleted fully processed file: ${path6.basename(filePath)}`);
           } else {
-            this.debug(`File ${path5.basename(filePath)} partially failed. Keeping it for next flush.`);
+            this.debug(`File ${path6.basename(filePath)} partially failed. Keeping it for next flush.`);
           }
         } catch (err) {
-          await this.writeFallbackLog("ERROR", `\u5904\u7406\u6587\u4EF6 ${path5.basename(filePath)} \u5F02\u5E38:`, err);
+          await this.writeFallbackLog("ERROR", `\u5904\u7406\u6587\u4EF6 ${path6.basename(filePath)} \u5F02\u5E38:`, err);
         }
       }
     } catch (err) {
@@ -1394,8 +1414,8 @@ var Reporter = class {
 
 // src/ws-client.ts
 import WebSocket from "ws";
-import path6 from "path";
-import fs5 from "fs/promises";
+import path7 from "path";
+import fs6 from "fs/promises";
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var HEARTBEAT_ACK_TIMEOUT_MS = 75e3;
 var AGENT_SCAN_INTERVAL_MS = 3 * 60 * 1e3;
@@ -1425,10 +1445,10 @@ var GatewayWsClient = class {
         }
       }
       logLine += "\n";
-      const logsDir = path6.join(openclawHome(), "logs");
-      fs5.mkdir(logsDir, { recursive: true }).then(() => {
-        const logPath = path6.join(logsDir, "skill-logger.err");
-        fs5.appendFile(logPath, logLine).catch(() => {
+      const logsDir = path7.join(openclawHome(), "logs");
+      fs6.mkdir(logsDir, { recursive: true }).then(() => {
+        const logPath = path7.join(logsDir, "skill-logger.err");
+        fs6.appendFile(logPath, logLine).catch(() => {
         });
       }).catch(() => {
       });
@@ -1532,7 +1552,7 @@ var GatewayWsClient = class {
       const rootPath = openclawHome();
       let entries = [];
       try {
-        entries = await fs5.readdir(rootPath);
+        entries = await fs6.readdir(rootPath);
       } catch (e) {
         this.currentAgentIds = /* @__PURE__ */ new Set();
         this.appendLogToFile("WARN", "AgentScan", "OpenClaw home is not readable; reporting empty agent list", e);
@@ -1543,7 +1563,7 @@ var GatewayWsClient = class {
       for (const entry of entries) {
         if (entry.startsWith("workspace-assistant-")) {
           const suffix = entry.replace("workspace-assistant-", "").trim();
-          if (suffix && suffix === path6.basename(suffix) && !suffix.startsWith(".")) {
+          if (suffix && suffix === path7.basename(suffix) && !suffix.startsWith(".")) {
             newAgentIds.add(`assistant-${suffix}`);
           }
         }
@@ -1689,10 +1709,10 @@ var GatewayWsClient = class {
       this.appendLogToFile("WARN", "Command", `Message dropped: missing action or userId`, msg);
       return;
     }
-    const safeUserId = path6.basename(userId);
-    const safeCode = code ? path6.basename(code) : void 0;
+    const safeUserId = path7.basename(userId);
+    const safeCode = code ? path7.basename(code) : void 0;
     const pureId = safeUserId.replace(/^assistant-/, "");
-    const targetDir = path6.join(openclawHome(), `workspace-assistant-${pureId}`, "skills");
+    const targetDir = path7.join(openclawHome(), `workspace-assistant-${pureId}`, "skills");
     try {
       if (action === "INSTALL_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
@@ -1710,14 +1730,14 @@ var GatewayWsClient = class {
         if (!safeCode) throw new Error("Missing code parameter");
         console.log(`[skill-logger-plugin][WS] Executing UNINSTALL for user ${userId}, code: ${safeCode}`);
         this.appendLogToFile("INFO", "Command", `UNINSTALL_SKILL received`, { userId, code: safeCode });
-        const skillPath = path6.join(targetDir, safeCode);
-        await fs5.rm(skillPath, { recursive: true, force: true });
+        const skillPath = path7.join(targetDir, safeCode);
+        await fs6.rm(skillPath, { recursive: true, force: true });
         this.reply(replyId, { success: true, message: `Skill ${safeCode} removed`, action });
       } else if (action === "LIST_SKILLS") {
         let list = [];
         let targetDirExists = false;
         try {
-          const targetStat = await fs5.stat(targetDir);
+          const targetStat = await fs6.stat(targetDir);
           targetDirExists = targetStat.isDirectory();
         } catch (err) {
           if (err?.code !== "ENOENT") throw err;
@@ -1725,18 +1745,18 @@ var GatewayWsClient = class {
         if (!targetDirExists) {
           throw new Error(`Target skills directory does not exist: ${targetDir}`);
         }
-        const entries = await fs5.readdir(targetDir, { withFileTypes: true });
+        const entries = await fs6.readdir(targetDir, { withFileTypes: true });
         const dirs = entries.filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !e.name.startsWith("."));
         for (const e of dirs) {
-          const skillDir = path6.join(targetDir, e.name);
-          const skillMdPath = path6.join(skillDir, "SKILL.md");
+          const skillDir = path7.join(targetDir, e.name);
+          const skillMdPath = path7.join(skillDir, "SKILL.md");
           try {
-            const stat = await fs5.stat(skillMdPath);
+            const stat = await fs6.stat(skillMdPath);
             if (!stat.isFile()) continue;
           } catch (err) {
             continue;
           }
-          const metaPath = path6.join(skillDir, ".meta.json");
+          const metaPath = path7.join(skillDir, ".meta.json");
           let isPlatform = false;
           let isBuiltIn = e.isSymbolicLink();
           let metaData = null;
@@ -1744,12 +1764,10 @@ var GatewayWsClient = class {
           let description = "";
           let skillVersion = "";
           try {
-            const mdContent = await fs5.readFile(skillMdPath, "utf8");
+            const mdContent = await fs6.readFile(skillMdPath, "utf8");
             const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(mdContent)?.[1] ?? "";
             const parsedName = /(^|\n)name:\s*(.+)/.exec(fm)?.[2]?.trim();
             if (parsedName) name = parsedName;
-            const parsedVersion = /(^|\n)version:\s*(.+)/i.exec(fm)?.[2]?.trim();
-            if (parsedVersion) skillVersion = parsedVersion.replace(/^['"]|['"]$/g, "").replace(/\s+#.*$/, "");
             const descMatch = /(^|\n)description:\s*(?:>\s*\n\s*)?(.*?)(?=\n[a-z]+:|\n---|$)/is.exec(fm);
             if (descMatch && descMatch[2]) {
               description = descMatch[2].replace(/\n\s+/g, " ").trim();
@@ -1757,7 +1775,7 @@ var GatewayWsClient = class {
           } catch (err) {
           }
           try {
-            const metaContent = await fs5.readFile(metaPath, "utf8");
+            const metaContent = await fs6.readFile(metaPath, "utf8");
             const parsed = JSON.parse(metaContent);
             if (parsed) {
               if (parsed.ownerId === "CMS" || parsed.ownerId === "CMS_COMPAT") isPlatform = true;
@@ -1766,12 +1784,14 @@ var GatewayWsClient = class {
             }
           } catch (err) {
           }
+          const resolvedVersion = await readSkillVersion2(skillDir);
+          if (resolvedVersion) skillVersion = resolvedVersion;
           if (isPlatform) {
             list.push({
               code: e.name,
               isPlatform: true,
               isBuiltIn,
-              version: metaData?.version || skillVersion,
+              version: skillVersion,
               name,
               description,
               publishedAt: metaData?.publishedAt
@@ -1840,7 +1860,7 @@ var GatewayWsClient = class {
 };
 
 // src/hooks.ts
-import path7 from "node:path";
+import path8 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
 var PENDING_TTL_MS = 30 * 60 * 1e3;
 var PENDING_MAX = 5e3;
@@ -1849,7 +1869,7 @@ function toMySQLDateTime(d) {
   return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
 }
 function isSkillMdReadPath(filePath) {
-  return path7.basename(filePath) === "SKILL.md";
+  return path8.basename(filePath) === "SKILL.md";
 }
 function extractAppKey(event, ctx) {
   try {
@@ -1971,8 +1991,8 @@ var Hooks = class {
       if (toolName === "read") {
         const filePath = params.path ?? params.file_path ?? "";
         if (!isSkillMdReadPath(filePath)) return;
-        const rootDir = path7.dirname(filePath);
-        const skillName = this.configSync.resolveSkillName(rootDir) || path7.basename(rootDir);
+        const rootDir = path8.dirname(filePath);
+        const skillName = this.configSync.resolveSkillName(rootDir) || path8.basename(rootDir);
         if (!skillName) return;
         this.debug(`Intercepted 'read' for SKILL.md. Attributed to skill: ${skillName}`);
         this.recordTrigger(skillName, "inline", "read", ctx, appKey);
@@ -2153,9 +2173,9 @@ var definition = {
   register(api) {
     let pkgVersion = "unknown";
     try {
-      const dir = path8.dirname(fileURLToPath2(import.meta.url));
-      const pkgPath = path8.join(dir, "..", "package.json");
-      const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+      const dir = path9.dirname(fileURLToPath2(import.meta.url));
+      const pkgPath = path9.join(dir, "..", "package.json");
+      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
       if (pkg.version) pkgVersion = pkg.version;
     } catch {
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spzhongwin/skill-logger-plugin",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "exports": "./dist/index.js",
   "scripts": {

package/src/config-sync.ts

@@ -18,7 +18,7 @@ import { type PluginPaths, resolveAgentSkillDirs, openclawHome } from "./paths.t
 import { buildIndex, emptyIndex, type MatchIndex } from "./matcher.ts";
 import { defaultFetch } from "./http.ts";
 import { isOutdated } from "./semver.ts";
-import { parseSkillVersion } from "./skill-version.ts";
+import { parseSkillVersion, readSkillVersion } from "./skill-version.ts";
 import type { OutdatedCopy } from "./updater.ts";
 
 // 保持对外导出位置不变（历史测试从 config-sync 导入）。
@@ -242,7 +242,7 @@ export class ConfigSync {
       const content = await fs.readFile(skillMdPath, "utf-8");
       const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content)?.[1] ?? "";
       const name = /(^|\n)name:\s*(.+)/.exec(fm)?.[2]?.trim() || path.basename(rootDir);
-      const version = parseSkillVersion(content);
+      const version = await readSkillVersion(rootDir, content);
       const signature = await this.computeSignature(rootDir, skillMdPath, version);
       return { name, version, rootDir, signature };
     } catch {

package/src/skill-version.ts

@@ -1,8 +1,39 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * 优先从 .meta.json 获取版本，如果没有，再回退到 SKILL.md 提取。
+ */
+export async function readSkillVersion(rootDir: string, skillMdContent?: string): Promise<string | undefined> {
+  // 1. 优先尝试从 .meta.json 中读取
+  try {
+    const metaPath = path.join(rootDir, ".meta.json");
+    const metaContent = await fs.readFile(metaPath, "utf-8");
+    const meta = JSON.parse(metaContent);
+    if (meta && typeof meta.version === "string" && meta.version.trim() && meta.version !== "unknown") {
+      return meta.version.trim();
+    }
+  } catch {
+    // 忽略异常，继续 fallback
+  }
+
+  // 2. 降级到 SKILL.md 提取
+  if (!skillMdContent) {
+    try {
+      skillMdContent = await fs.readFile(path.join(rootDir, "SKILL.md"), "utf-8");
+    } catch {
+      return undefined;
+    }
+  }
+
+  return parseSkillVersion(skillMdContent);
+}
+
 /**
  * 从 SKILL.md 文本中提取版本号（纯正则、不借助任何模型）。
  *
  * 兼容点：
- *  - 键名：英文 `version` / `Version`（大小写不敏感）、中文 `版本号` / `版本`；
+ *  - 键名：英文 `version` / `Version`（大小写不敏感）、中文 `当前版本号` / `当前版本` / `版本号` / `版本`；
  *  - 冒号：半角 `:` 或全角 `：`；
  *  - 取值：去除包裹引号、行尾 ` # 注释`、首尾空白。
  *
@@ -11,7 +42,7 @@
  * 取不到返回 undefined（该 skill 不参与版本更新）。
  */
 export function parseSkillVersion(content: string): string | undefined {
-  const m = /(?:^|\r?\n)[ \t]*(?:version|版本号|版本)[ \t]*[:：][ \t]*(.+)/i.exec(content);
+  const m = /(?:^|\r?\n)[ \t]*(?:version|当前版本号|当前版本|版本号|版本)[ \t]*[:：][ \t]*(.+)/i.exec(content);
   if (!m) return undefined;
   const v = m[1]
     .replace(/\s+#.*$/, "") // 行尾注释

package/src/updater.ts

@@ -23,7 +23,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { randomUUID, createHash } from "node:crypto";
 import type { PluginConfig } from "./types.ts";
-import { parseSkillVersion } from "./skill-version.ts";
+import { parseSkillVersion, readSkillVersion } from "./skill-version.ts";
 
 const execFileAsync = promisify(execFile);
 
@@ -193,6 +193,19 @@ export class SkillUpdater {
         return;
       }
 
+      // 守卫：下载包必须能解析出版本号，否则不做覆盖（服务端要求：无版本号不更新）。
+      let packageVersion: string | undefined;
+      try {
+        packageVersion = await readSkillVersion(srcRoot);
+      } catch (err) {
+        console.warn(`[skill-logger-plugin] ${skillName}@${version} 读取下载包版本号失败，放弃覆盖`, err);
+        return;
+      }
+      if (!packageVersion) {
+        console.warn(`[skill-logger-plugin] ${skillName}@${version} 下载包无版本号，放弃覆盖`);
+        return;
+      }
+
       // [兼容处理] 缺少 .meta.json 时主动补齐
       const metaPath = path.join(srcRoot, ".meta.json");
       if (!(await this.exists(metaPath))) {
@@ -200,25 +213,11 @@ export class SkillUpdater {
         await fs.writeFile(metaPath, JSON.stringify({
           ownerId: 'CMS_COMPAT',
           slug: skillName,
-          version: version,
+          version: packageVersion,
           publishedAt: Date.now()
         }, null, 2));
       }
 
-      // 守卫：下载包的 SKILL.md 必须能解析出版本号，否则不做覆盖（服务端要求：无版本号不更新）。
-      let packageVersion: string | undefined;
-      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);
@@ -372,8 +371,7 @@ export class SkillUpdater {
         let parsedVersion = version || "unknown";
         if (!version) {
           try {
-            const newSkillMd = await fs.readFile(path.join(srcRoot, "SKILL.md"), "utf-8");
-            parsedVersion = parseSkillVersion(newSkillMd) || "unknown";
+            parsedVersion = (await readSkillVersion(srcRoot)) || "unknown";
           } catch {}
         }
         

package/src/ws-client.ts

@@ -3,6 +3,7 @@ import path from "path";
 import fs from "fs/promises";
 import { SkillUpdater } from "./updater.ts";
 import { openclawHome } from "./paths.ts";
+import { readSkillVersion } from "./skill-version.ts";
 
 const HEARTBEAT_INTERVAL_MS = 30_000;
 const HEARTBEAT_ACK_TIMEOUT_MS = 75_000;
@@ -420,8 +421,6 @@ export class GatewayWsClient {
             const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(mdContent)?.[1] ?? "";
             const parsedName = /(^|\n)name:\s*(.+)/.exec(fm)?.[2]?.trim();
             if (parsedName) name = parsedName;
-            const parsedVersion = /(^|\n)version:\s*(.+)/i.exec(fm)?.[2]?.trim();
-            if (parsedVersion) skillVersion = parsedVersion.replace(/^['"]|['"]$/g, '').replace(/\s+#.*$/, '');
 
             const descMatch = /(^|\n)description:\s*(?:>\s*\n\s*)?(.*?)(?=\n[a-z]+:|\n---|$)/is.exec(fm);
             if (descMatch && descMatch[2]) {
@@ -438,13 +437,16 @@ export class GatewayWsClient {
               metaData = parsed;
             }
           } catch (err) {}
+
+          const resolvedVersion = await readSkillVersion(skillDir);
+          if (resolvedVersion) skillVersion = resolvedVersion;
           
           if (isPlatform) {
             list.push({
               code: e.name,
               isPlatform: true,
               isBuiltIn: isBuiltIn,
-              version: metaData?.version || skillVersion,
+              version: skillVersion,
               name,
               description,
               publishedAt: metaData?.publishedAt