@spzhongwin/skill-logger-plugin 1.0.11 → 1.0.13

package/dist/index.js

@@ -106,7 +106,6 @@ import fsSync from "node:fs";
 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
@@ -139,14 +138,37 @@ function parseSkillVersion(content) {
 }
 
 // src/updater.ts
-var execFileAsync = promisify(execFile);
+var EXTRACT_TIMEOUT_MS = 3e4;
 var ATTEMPT_COOLDOWN_MS = 30 * 60 * 1e3;
 function skillIdentityHash(code, version) {
   return createHash("sha256").update(`${code} ${code} ${version}`).digest("hex");
 }
+function extractorCommandForPlatform(platform, zipPath, destDir) {
+  return platform === "darwin" ? { command: "ditto", args: ["-x", "-k", zipPath, destDir] } : { command: "unzip", args: ["-o", "-q", zipPath, "-d", destDir] };
+}
+function runExtractor(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = execFile(command, args, {
+      encoding: "utf8",
+      timeout: EXTRACT_TIMEOUT_MS,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024 * 1024
+    }, (error, _stdout, stderr) => {
+      if (!error) {
+        resolve();
+        return;
+      }
+      const detail = String(stderr || "").trim();
+      const timeout = error.killed ? `\uFF0C\u8D85\u8FC7 ${EXTRACT_TIMEOUT_MS}ms \u5DF2\u7EC8\u6B62` : "";
+      reject(new Error(`${command} \u89E3\u538B\u5931\u8D25${timeout}: ${detail || error.message}`));
+    });
+    child.stdin?.end();
+  });
+}
 async function systemUnzip(zipPath, destDir) {
   await fs3.mkdir(destDir, { recursive: true });
-  await execFileAsync("unzip", ["-o", "-q", zipPath, "-d", destDir]);
+  const { command, args } = extractorCommandForPlatform(process.platform, zipPath, destDir);
+  await runExtractor(command, args);
 }
 var SkillUpdater = class {
   getConfig;
@@ -395,36 +417,85 @@ var SkillUpdater = class {
     }
   }
   async manualInstall(options) {
-    const { code, force, targetDir } = options;
+    const { code, force, targetDir, additionalTargetDirs = [], trace } = options;
     let { url, version } = options;
-    if (!url) {
-      const dl = await this.fetchDownloadUrl(code, version || "latest");
-      if (!dl?.url) {
-        return { success: false, message: `\u65E0\u6CD5\u83B7\u53D6\u6280\u80FD ${code} \u7684\u4E0B\u8F7D\u5730\u5740` };
+    const startedAt = Date.now();
+    let currentStage = "install.start";
+    let work;
+    const emit = (stage, data) => {
+      currentStage = stage;
+      try {
+        trace?.(stage, data);
+      } catch {
       }
-      url = dl.url;
-      version = dl.version || version;
-    }
-    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 = path3.join(this.tmpDir, `slp-manual-${randomUUID()}`);
-    await fs3.mkdir(work, { recursive: true });
+    };
+    emit("install.start", {
+      code,
+      version: version || "latest",
+      force,
+      hasDirectUrl: Boolean(url),
+      targetCount: 1 + additionalTargetDirs.length
+    });
     try {
+      if (!url) {
+        const lookupStartedAt = Date.now();
+        emit("download_url.lookup.start", { code, version: version || "latest" });
+        const dl = await this.fetchDownloadUrl(code, version || "latest");
+        if (!dl?.url) {
+          const message = `\u65E0\u6CD5\u83B7\u53D6\u6280\u80FD ${code} \u7684\u4E0B\u8F7D\u5730\u5740`;
+          emit("install.failed", { stage: currentStage, message, elapsedMs: Date.now() - startedAt });
+          return { success: false, message };
+        }
+        url = dl.url;
+        version = dl.version || version;
+        emit("download_url.lookup.completed", {
+          version: version || "latest",
+          url,
+          elapsedMs: Date.now() - lookupStartedAt
+        });
+      }
+      const targetSkillPath = path3.join(targetDir, code);
+      if (!force && await this.exists(targetSkillPath)) {
+        const message = `\u6280\u80FD ${code} \u5DF2\u5B58\u5728\u4E8E\u76EE\u6807\u76EE\u5F55`;
+        emit("install.failed", { stage: currentStage, message, elapsedMs: Date.now() - startedAt });
+        return { success: false, message };
+      }
+      work = path3.join(this.tmpDir, `slp-manual-${randomUUID()}`);
+      await fs3.mkdir(work, { recursive: true });
       const zipPath = path3.join(work, "pkg.zip");
+      const downloadStartedAt = Date.now();
+      emit("download.request.start", { url });
       const res = await this.fetchImpl(url);
+      emit("download.headers.received", {
+        status: res.status,
+        contentLength: res.headers?.get("content-length") || void 0,
+        contentType: res.headers?.get("content-type") || void 0,
+        elapsedMs: Date.now() - downloadStartedAt
+      });
       if (!res.ok) {
-        return { success: false, message: `\u4E0B\u8F7D\u5931\u8D25: HTTP ${res.status}` };
+        const message = `\u4E0B\u8F7D\u5931\u8D25: HTTP ${res.status}`;
+        emit("install.failed", { stage: currentStage, message, elapsedMs: Date.now() - startedAt });
+        return { success: false, message };
       }
       const buf = Buffer.from(await res.arrayBuffer());
+      emit("download.body.completed", {
+        bytes: buf.byteLength,
+        elapsedMs: Date.now() - downloadStartedAt
+      });
       await fs3.writeFile(zipPath, buf);
+      emit("download.file.written", { bytes: buf.byteLength });
       const staging = path3.join(work, "staging");
+      const unzipStartedAt = Date.now();
+      emit("unzip.start", { extractor: process.platform === "darwin" ? "ditto" : "unzip" });
       await this.unzip(zipPath, staging);
+      emit("unzip.completed", { elapsedMs: Date.now() - unzipStartedAt });
       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 message = `\u4E0B\u8F7D\u5305\u5185\u672A\u627E\u5230 SKILL.md\uFF0C\u975E\u6CD5\u7684\u6280\u80FD\u5305\u7ED3\u6784`;
+        emit("install.failed", { stage: currentStage, message, elapsedMs: Date.now() - startedAt });
+        return { success: false, message };
       }
+      emit("skill_root.located");
       const metaPath = path3.join(srcRoot, ".meta.json");
       if (!await this.exists(metaPath)) {
         let parsedVersion = version || "unknown";
@@ -442,13 +513,37 @@ var SkillUpdater = class {
           publishedAt: Date.now()
         }, null, 2));
       }
-      await this.replaceDir(srcRoot, targetSkillPath);
+      const targets = [targetDir, ...additionalTargetDirs];
+      for (let index = 0; index < targets.length; index += 1) {
+        const rootDir = targets[index];
+        const targetPath = path3.join(rootDir, code);
+        const replaceStartedAt = Date.now();
+        emit("target.replace.start", { targetDir: rootDir, targetIndex: index, targetCount: targets.length });
+        await this.replaceDir(srcRoot, targetPath);
+        emit("target.replace.completed", {
+          targetDir: rootDir,
+          targetIndex: index,
+          targetCount: targets.length,
+          elapsedMs: Date.now() - replaceStartedAt
+        });
+      }
+      emit("install.completed", { elapsedMs: Date.now() - startedAt, targetCount: targets.length });
       return { success: true, message: `\u6280\u80FD ${code} \u5B89\u88C5/\u66F4\u65B0\u6210\u529F` };
     } catch (err) {
+      emit("install.failed", {
+        stage: currentStage,
+        errorName: err?.name,
+        message: err?.message || String(err),
+        stack: err?.stack,
+        elapsedMs: Date.now() - startedAt
+      });
       return { success: false, message: `\u6267\u884C\u51FA\u9519: ${err.message}` };
     } finally {
-      await fs3.rm(work, { recursive: true, force: true }).catch(() => {
-      });
+      if (work) {
+        await fs3.rm(work, { recursive: true, force: true }).catch(() => {
+        });
+        emit("cleanup.completed", { elapsedMs: Date.now() - startedAt });
+      }
     }
   }
 };
@@ -1281,11 +1376,11 @@ import path6 from "node:path";
 // src/identity.ts
 import os3 from "node:os";
 import { execFile as execFile2 } from "node:child_process";
-import { promisify as promisify2 } from "node:util";
-var execFileAsync2 = promisify2(execFile2);
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile2);
 async function getGitConfigValue(key) {
   try {
-    const { stdout } = await execFileAsync2("git", ["config", "--global", key]);
+    const { stdout } = await execFileAsync("git", ["config", "--global", key]);
     return stdout.trim();
   } catch {
     console.warn(
@@ -1562,6 +1657,9 @@ function normalizeAssistantUserId(userId) {
   if (!ASSISTANT_WORKSPACE_ID_RE.test(pureId)) return void 0;
   return pureId;
 }
+function shouldSyncBuiltInTemplate(action, isBuiltIn) {
+  return action === "UPDATE_SKILL" && isBuiltIn === true;
+}
 var GatewayWsClient = class {
   ws = null;
   options;
@@ -1598,6 +1696,14 @@ var GatewayWsClient = class {
     } catch (e) {
     }
   }
+  createInstallTrace(context) {
+    return (stage, data) => {
+      this.appendLogToFile(stage === "install.failed" ? "ERROR" : "INFO", "Install", stage, {
+        ...context,
+        ...data
+      });
+    };
+  }
   constructor(options) {
     this.options = options;
   }
@@ -1849,8 +1955,16 @@ var GatewayWsClient = class {
    * 核心指令分发中心：完全跳过沙盒，基于 userId 直接进行底层物理文件操作
    */
   async handleMessage(msg) {
-    const { action, userId, code, url, force, version, replyId } = msg;
-    this.appendLogToFile("INFO", "Command", `Received WS message`, { action, userId, code, version, replyId });
+    const { action, userId, code, url, force, version, replyId, isBuiltIn } = msg;
+    this.appendLogToFile("INFO", "Command", `Received WS message`, {
+      action,
+      userId,
+      code,
+      version,
+      replyId,
+      isBuiltIn,
+      hasDirectUrl: Boolean(url)
+    });
     if (!action || !userId) {
       this.appendLogToFile("WARN", "Command", `Message dropped: missing action or userId`, msg);
       return;
@@ -1872,7 +1986,8 @@ var GatewayWsClient = class {
           url,
           version,
           force: force !== false,
-          targetDir
+          targetDir,
+          trace: this.createInstallTrace({ action, replyId, userId, code: safeCode })
         });
         this.reply(replyId, { success: result.success, message: result.message, action });
       } else if (action === "UNINSTALL_SKILL") {
@@ -1907,7 +2022,7 @@ var GatewayWsClient = class {
           }
           const metaPath = path7.join(skillDir, ".meta.json");
           let isPlatform = false;
-          let isBuiltIn = e.isSymbolicLink();
+          let isBuiltIn2 = e.isSymbolicLink();
           let metaData = null;
           let name = e.name;
           let description = "";
@@ -1928,7 +2043,7 @@ var GatewayWsClient = class {
             const parsed = JSON.parse(metaContent);
             if (parsed) {
               if (parsed.ownerId === "CMS" || parsed.ownerId === "CMS_COMPAT") isPlatform = true;
-              if (parsed.isBuiltIn === true || parsed.ownerId === "built-in") isBuiltIn = true;
+              if (parsed.isBuiltIn === true || parsed.ownerId === "built-in") isBuiltIn2 = true;
               metaData = parsed;
             }
           } catch (err) {
@@ -1939,7 +2054,7 @@ var GatewayWsClient = class {
             list.push({
               code: e.name,
               isPlatform: true,
-              isBuiltIn,
+              isBuiltIn: isBuiltIn2,
               version: skillVersion,
               name,
               description,
@@ -1949,7 +2064,7 @@ var GatewayWsClient = class {
             list.push({
               code: e.name,
               isPlatform: false,
-              isBuiltIn,
+              isBuiltIn: isBuiltIn2,
               version: skillVersion,
               name,
               description
@@ -1960,21 +2075,54 @@ var GatewayWsClient = class {
       } else if (action === "UPDATE_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
         const delayMs = Math.random() * 5e3;
+        const syncBuiltInTemplate = shouldSyncBuiltInTemplate(action, isBuiltIn);
         console.log(`[skill-logger-plugin][WS] Scheduled UPDATE for user ${userId}, code: ${safeCode} in ${Math.round(delayMs)}ms`);
-        this.appendLogToFile("INFO", "Command", `Scheduled UPDATE_SKILL`, { userId, code: safeCode, version, delayMs: Math.round(delayMs) });
+        this.appendLogToFile("INFO", "Command", `Scheduled UPDATE_SKILL`, {
+          userId,
+          code: safeCode,
+          version,
+          isBuiltIn,
+          syncBuiltInTemplate,
+          delayMs: Math.round(delayMs)
+        });
         setTimeout(async () => {
           try {
-            await this.options.updater.manualInstall({
+            const additionalTargetDirs = syncBuiltInTemplate ? [path7.join(openclawHome(), "workspace-xgjk-assistant-template", "skills")] : [];
+            const result = await this.options.updater.manualInstall({
               code: safeCode,
               url,
               version,
               force: true,
-              targetDir
+              targetDir,
+              additionalTargetDirs,
+              trace: this.createInstallTrace({
+                action,
+                replyId,
+                userId,
+                code: safeCode,
+                isBuiltIn,
+                syncBuiltInTemplate
+              })
+            });
+            this.appendLogToFile(result.success ? "INFO" : "ERROR", "Command", `UPDATE_SKILL completed`, {
+              userId,
+              code: safeCode,
+              replyId,
+              success: result.success,
+              message: result.message,
+              syncBuiltInTemplate
             });
             if (replyId) {
-              this.reply(replyId, { success: true, message: `Skill ${safeCode} updated successfully`, action });
+              this.reply(replyId, { success: result.success, message: result.message, action });
             }
           } catch (e) {
+            this.appendLogToFile("ERROR", "Command", `UPDATE_SKILL threw`, {
+              userId,
+              code: safeCode,
+              replyId,
+              message: e?.message || String(e),
+              stack: e?.stack
+            });
             if (replyId) this.reply(replyId, { success: false, message: e.message, action });
           }
         }, delayMs);
@@ -1985,11 +2133,25 @@ var GatewayWsClient = class {
         this.appendLogToFile("INFO", "Command", `INSTALL_EXPERT received`, { userId, code: safeCode, version: version2, downloadUrl });
         const userSkillRoot = path7.join(openclawHome(), `workspace-assistant-${pureId}`, ".user");
         const expertTarget = path7.join(userSkillRoot, "experts", safeCode);
-        await fs6.mkdir(path7.dirname(expertTarget), { recursive: true });
-        const expertResult = await this.options.updater.installZipFromUrl(downloadUrl, expertTarget);
-        if (!expertResult.success) {
-          throw new Error(`\u4E13\u5BB6\u5B89\u88C5\u5931\u8D25: ${expertResult.message}`);
+        let skipInstall = false;
+        const metaPath = path7.join(expertTarget, ".meta.json");
+        try {
+          const raw = await fs6.readFile(metaPath, "utf-8");
+          const existing = JSON.parse(raw);
+          if (existing.version && existing.version === (version2 || "1.0.0")) {
+            skipInstall = true;
+          }
+        } catch {
+        }
+        if (!skipInstall) {
+          await fs6.mkdir(path7.dirname(expertTarget), { recursive: true });
+          const expertResult = await this.options.updater.installZipFromUrl(downloadUrl, expertTarget);
+          if (!expertResult.success) {
+            throw new Error(`\u4E13\u5BB6\u5B89\u88C5\u5931\u8D25: ${expertResult.message}`);
+          }
         }
+        const meta = { code: safeCode, name, version: version2 || "1.0.0", installedAt: Date.now() };
+        await fs6.writeFile(metaPath, JSON.stringify(meta, null, 2));
         const skillTargetRoot = path7.join(userSkillRoot, "skills");
         await fs6.mkdir(skillTargetRoot, { recursive: true });
         const skillResults = [];
@@ -2014,48 +2176,42 @@ var GatewayWsClient = class {
           action,
           data: { expertCode: safeCode, skills: skillResults }
         });
-      } else if (action === "GET_EXPERT_REGISTRY") {
-        console.log(`[skill-logger-plugin][WS] Executing GET_EXPERT_REGISTRY for user ${userId}`);
-        this.appendLogToFile("INFO", "Command", `GET_EXPERT_REGISTRY received`, { userId });
-        const registryFilePath = path7.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "expert-registry.yaml");
-        let content = "";
-        let fileExists = false;
+      } else if (action === "UNINSTALL_EXPERT") {
+        if (!safeCode) throw new Error("Missing code parameter");
+        console.log(`[skill-logger-plugin][WS] Executing UNINSTALL_EXPERT for user ${userId}, code: ${safeCode}`);
+        this.appendLogToFile("INFO", "Command", `UNINSTALL_EXPERT received`, { userId, code: safeCode });
+        const expertPath = path7.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts", safeCode);
+        await fs6.rm(expertPath, { recursive: true, force: true });
+        this.reply(replyId, { success: true, message: `\u4E13\u5BB6 ${safeCode} \u5DF2\u5378\u8F7D`, action });
+      } else if (action === "LIST_EXPERTS") {
+        console.log(`[skill-logger-plugin][WS] Executing LIST_EXPERTS for user ${userId}`);
+        this.appendLogToFile("INFO", "Command", `LIST_EXPERTS received`, { userId });
+        const expertsDir = path7.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts");
+        const list = [];
         try {
-          const stat = await fs6.stat(registryFilePath);
-          fileExists = stat.isFile();
-        } catch (err) {
-          if (err?.code !== "ENOENT") throw err;
-        }
-        if (fileExists) {
-          content = await fs6.readFile(registryFilePath, "utf8");
-          const expertsList = [];
-          const lines = content.split("\n");
-          let currentExpert = null;
-          for (const line of lines) {
-            const trimmed = line.trim();
-            if (trimmed.startsWith("#")) continue;
-            const idMatch = line.match(/^\s*-\s*id:\s*(.+)$/);
-            if (idMatch) {
-              if (currentExpert && currentExpert.id) expertsList.push(currentExpert);
-              currentExpert = { id: idMatch[1].trim() };
-              continue;
-            }
-            if (currentExpert) {
-              const nameMatch = line.match(/^\s*name:\s*(.+)$/);
-              if (nameMatch) {
-                currentExpert.name = nameMatch[1].trim();
-              }
-              const descMatch = line.match(/^\s*description:\s*(.+)$/);
-              if (descMatch) {
-                currentExpert.description = descMatch[1].trim();
+          const stat = await fs6.stat(expertsDir);
+          if (stat.isDirectory()) {
+            const entries = await fs6.readdir(expertsDir, { withFileTypes: true });
+            for (const e of entries) {
+              if (!e.isDirectory()) continue;
+              const metaPath = path7.join(expertsDir, e.name, ".meta.json");
+              try {
+                const raw = await fs6.readFile(metaPath, "utf-8");
+                const meta = JSON.parse(raw);
+                list.push({
+                  code: meta.code || e.name,
+                  name: meta.name || e.name,
+                  version: meta.version || "",
+                  installedAt: meta.installedAt
+                });
+              } catch {
+                list.push({ code: e.name, name: e.name, version: "" });
               }
             }
           }
-          if (currentExpert && currentExpert.id) expertsList.push(currentExpert);
-          this.reply(replyId, { success: true, data: expertsList, action });
-        } else {
-          this.reply(replyId, { success: false, message: `\u672A\u627E\u5230\u7528\u6237\u6280\u80FD\u914D\u7F6E\u6587\u4EF6\uFF0C\u53EF\u80FD\u5C1A\u672A\u6CE8\u518C\u6216\u6587\u4EF6\u5DF2\u4E22\u5931`, action });
+        } catch {
         }
+        this.reply(replyId, { success: true, data: list, action });
       } else {
         console.warn(`[skill-logger-plugin][WS] Unknown action: ${action}`);
         this.appendLogToFile("WARN", "Command", `Unknown action: ${action}`);
@@ -2072,7 +2228,13 @@ var GatewayWsClient = class {
       this.appendLogToFile("WARN", "Command", `Cannot reply: WS closed or missing replyId`, { replyId });
       return;
     }
-    this.ws.send(JSON.stringify({ type: "REPLY", replyId, ...payload }));
+    this.ws.send(JSON.stringify({ type: "REPLY", replyId, ...payload }), (err) => {
+      if (err) {
+        this.appendLogToFile("ERROR", "Command", `Reply send failed`, { replyId, message: err.message });
+        return;
+      }
+      this.appendLogToFile("INFO", "Command", `Reply sent`, { replyId });
+    });
   }
   destroy() {
     this.isDestroyed = true;

package/dist/index.test.js

@@ -0,0 +1,39 @@
+import { describe, it, before } from "node:test";
+import assert from "node:assert/strict";
+let isSkillMdReadPath;
+let extractApiPluginConfig;
+describe("isSkillMdReadPath", () => {
+    before(async () => {
+        ({ isSkillMdReadPath, extractApiPluginConfig } = await import("./index.ts"));
+    });
+    it("POSIX 路径 basename 为 SKILL.md 时为 true", () => {
+        assert.equal(isSkillMdReadPath("/x/y/my-skill/SKILL.md"), true);
+    });
+    it("Windows 风格路径", { skip: process.platform !== "win32" }, () => {
+        assert.equal(isSkillMdReadPath(String.raw `C:\x\y\my-skill\SKILL.md`), true);
+    });
+    it("fooSKILL.md / my-SKILL.md 不误判", () => {
+        assert.equal(isSkillMdReadPath("/tmp/fooSKILL.md"), false);
+        assert.equal(isSkillMdReadPath("/tmp/my-SKILL.md"), false);
+    });
+});
+describe("extractApiPluginConfig", () => {
+    it("从 OpenClaw 注入的 api.pluginConfig 初始化运行期配置", () => {
+        assert.deepEqual(extractApiPluginConfig({
+            pluginConfig: {
+                platformBaseUrl: "https://platform.example/api",
+                reportBaseUrl: "https://report.example/api",
+                authToken: "Bearer token",
+                recordUnattributed: true,
+            },
+        }), {
+            platformBaseUrl: "https://platform.example/api",
+            reportBaseUrl: "https://report.example/api",
+            authToken: "Bearer token",
+            recordUnattributed: true,
+        });
+    });
+    it("未配置时返回空对象", () => {
+        assert.deepEqual(extractApiPluginConfig({}), {});
+    });
+});

package/dist/integration.test.js

@@ -0,0 +1,102 @@
+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 { createHash } from "node:crypto";
+import { ConfigSync } from "./config-sync.ts";
+import { SkillUpdater } from "./updater.ts";
+const idHash = (code, version) => createHash("sha256").update(`${code} ${code} ${version}`).digest("hex");
+let dir;
+beforeEach(async () => {
+    dir = path.join(os.tmpdir(), `slp-int-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    await fs.mkdir(dir, { recursive: true });
+});
+afterEach(async () => {
+    await fs.rm(dir, { recursive: true, force: true });
+});
+describe("版本更新闭环（端到端）", () => {
+    it("config-pull 报最新版 → 检测落后 → 下载覆盖 → 再查收敛", async () => {
+        // 本地装一个 demo@1.0.0
+        const ws = path.join(dir, "workspace");
+        const skillDir = path.join(ws, "skills", "demo");
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(path.join(skillDir, "SKILL.md"), "---\nname: demo\nversion: 1.0.0\n---\nOLD\n");
+        const config = { platformBaseUrl: "https://api", autoUpdateSkills: true };
+        // 服务端最新版本（随测试推进而变化），模拟「更新后平台版本=本地版本」的收敛。
+        let platformLatest = "2.0.0";
+        // ConfigSync 的 fetch：/skill_config/pull → 带 latestVersion
+        const csFetch = async (_url, _init) => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ configs: [{ skillName: "demo", version: "1.0.0", latestVersion: platformLatest, functions: [] }] }),
+        });
+        // Updater 的 fetch：/skill_package/pull → {url, sha256}；GET → zip 字节
+        const upFetch = async (_url, init) => {
+            if (init?.method === "POST") {
+                return {
+                    ok: true,
+                    status: 200,
+                    json: async () => ({ url: "https://pkg/skill.zip", version: platformLatest, sha256: idHash("demo", platformLatest) }),
+                    arrayBuffer: async () => new ArrayBuffer(0),
+                };
+            }
+            return { ok: true, status: 200, json: async () => ({}), arrayBuffer: async () => new Uint8Array([1]).buffer };
+        };
+        // 解压：写出新版本的 SKILL.md（版本号与 platformLatest 一致）
+        const unzip = async (_zip, destDir) => {
+            const root = path.join(destDir, "demo");
+            await fs.mkdir(root, { recursive: true });
+            await fs.writeFile(path.join(root, "SKILL.md"), `---\nname: demo\nversion: ${platformLatest}\n---\nNEW\n`);
+        };
+        const updater = new SkillUpdater({ getConfig: () => config, fetchImpl: upFetch, unzip, tmpDir: dir });
+        const cs = new ConfigSync({
+            paths: { extensionsDir: path.join(dir, "ext"), syncStatePath: path.join(dir, "sync.json"), openclawConfigPath: path.join(dir, "openclaw.json") },
+            getConfig: () => config,
+            fetchImpl: csFetch,
+            resolveSkillDirs: () => [path.join(ws, "skills")],
+            updater,
+        });
+        // 第一轮：检测落后并覆盖到 2.0.0
+        await cs.checkVersionsAndUpdate();
+        const afterMd = await fs.readFile(path.join(skillDir, "SKILL.md"), "utf-8");
+        assert.ok(afterMd.includes("version: 2.0.0"), "应被更新到 2.0.0");
+        assert.ok(afterMd.includes("NEW"), "应为新内容");
+        // 第二轮：平台版本仍 2.0.0、本地已 2.0.0 → 收敛，无落后副本
+        platformLatest = "2.0.0";
+        await cs.checkVersionsAndUpdate();
+        assert.equal(cs.detectOutdated().length, 0, "更新后应收敛");
+        // sync.json 落了 installations 映射，且版本已是 2.0.0
+        const state = JSON.parse(await fs.readFile(path.join(dir, "sync.json"), "utf-8"));
+        assert.equal(state.installations.demo[0].version, "2.0.0");
+    });
+    it("autoUpdateSkills=false：检测到落后也不覆盖", async () => {
+        const ws = path.join(dir, "workspace");
+        const skillDir = path.join(ws, "skills", "demo");
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(path.join(skillDir, "SKILL.md"), "---\nname: demo\nversion: 1.0.0\n---\nOLD\n");
+        const config = { platformBaseUrl: "https://api", autoUpdateSkills: false };
+        const csFetch = async () => ({
+            ok: true,
+            status: 200,
+            json: async () => ({ configs: [{ skillName: "demo", version: "1.0.0", latestVersion: "2.0.0", functions: [] }] }),
+        });
+        let upCalled = 0;
+        const upFetch = async () => {
+            upCalled++;
+            return { ok: true, status: 200, json: async () => ({ url: "" }), arrayBuffer: async () => new ArrayBuffer(0) };
+        };
+        const updater = new SkillUpdater({ getConfig: () => config, fetchImpl: upFetch, unzip: async () => { }, tmpDir: dir });
+        const cs = new ConfigSync({
+            paths: { extensionsDir: path.join(dir, "ext"), syncStatePath: path.join(dir, "sync.json"), openclawConfigPath: path.join(dir, "openclaw.json") },
+            getConfig: () => config,
+            fetchImpl: csFetch,
+            resolveSkillDirs: () => [path.join(ws, "skills")],
+            updater,
+        });
+        await cs.checkVersionsAndUpdate();
+        assert.equal(cs.detectOutdated().length, 1, "仍检测到落后");
+        assert.equal(upCalled, 0, "关闭时不应发起下载");
+        assert.ok((await fs.readFile(path.join(skillDir, "SKILL.md"), "utf-8")).includes("OLD"), "文件保持原样");
+    });
+});