@spzhongwin/skill-logger-plugin 1.0.15 → 1.0.17

package/dist/index.js

@@ -360,25 +360,25 @@ var require_utils = __commonJS({
       }
       mkdirSync(folder);
     };
-    Utils.prototype.writeFileTo = function(path11, content, overwrite, attr) {
+    Utils.prototype.writeFileTo = function(path12, content, overwrite, attr) {
       const self = this;
-      if (self.fs.existsSync(path11)) {
+      if (self.fs.existsSync(path12)) {
         if (!overwrite) return false;
-        var stat = self.fs.statSync(path11);
+        var stat = self.fs.statSync(path12);
         if (stat.isDirectory()) {
           return false;
         }
       }
-      var folder = pth.dirname(path11);
+      var folder = pth.dirname(path12);
       if (!self.fs.existsSync(folder)) {
         self.makeDir(folder);
       }
       var fd;
       try {
-        fd = self.fs.openSync(path11, "w", 438);
+        fd = self.fs.openSync(path12, "w", 438);
       } catch (e) {
-        self.fs.chmodSync(path11, 438);
-        fd = self.fs.openSync(path11, "w", 438);
+        self.fs.chmodSync(path12, 438);
+        fd = self.fs.openSync(path12, "w", 438);
       }
       if (fd) {
         try {
@@ -387,22 +387,22 @@ var require_utils = __commonJS({
           self.fs.closeSync(fd);
         }
       }
-      self.fs.chmodSync(path11, attr || 438);
+      self.fs.chmodSync(path12, attr || 438);
       return true;
     };
-    Utils.prototype.writeFileToAsync = function(path11, content, overwrite, attr, callback) {
+    Utils.prototype.writeFileToAsync = function(path12, content, overwrite, attr, callback) {
       if (typeof attr === "function") {
         callback = attr;
         attr = void 0;
       }
       const self = this;
-      self.fs.exists(path11, function(exist) {
+      self.fs.exists(path12, function(exist) {
         if (exist && !overwrite) return callback(false);
-        self.fs.stat(path11, function(err, stat) {
+        self.fs.stat(path12, function(err, stat) {
           if (exist && stat && stat.isDirectory()) {
             return callback(false);
           }
-          var folder = pth.dirname(path11);
+          var folder = pth.dirname(path12);
           self.fs.exists(folder, function(exists) {
             if (!exists) {
               try {
@@ -415,16 +415,16 @@ var require_utils = __commonJS({
               self.fs.write(fd, content, 0, content.length, 0, function(writeErr) {
                 self.fs.close(fd, function() {
                   if (writeErr) return callback(false);
-                  self.fs.chmod(path11, attr || 438, function() {
+                  self.fs.chmod(path12, attr || 438, function() {
                     callback(true);
                   });
                 });
               });
             };
-            self.fs.open(path11, "w", 438, function(err2, fd) {
+            self.fs.open(path12, "w", 438, function(err2, fd) {
               if (err2) {
-                self.fs.chmod(path11, 438, function() {
-                  self.fs.open(path11, "w", 438, function(retryErr, fd2) {
+                self.fs.chmod(path12, 438, function() {
+                  self.fs.open(path12, "w", 438, function(retryErr, fd2) {
                     if (retryErr || !fd2) return callback(false);
                     writeToFd(fd2);
                   });
@@ -439,7 +439,7 @@ var require_utils = __commonJS({
         });
       });
     };
-    Utils.prototype.findFiles = function(path11) {
+    Utils.prototype.findFiles = function(path12) {
       const self = this;
       function findSync(dir, pattern, recursive, visited) {
         if (typeof pattern === "boolean") {
@@ -448,22 +448,22 @@ var require_utils = __commonJS({
         }
         let files = [];
         self.fs.readdirSync(dir).forEach(function(file) {
-          const path12 = pth.join(dir, file);
-          const stat = self.fs.statSync(path12);
-          if (!pattern || pattern.test(path12)) {
-            files.push(pth.normalize(path12) + (stat.isDirectory() ? self.sep : ""));
+          const path13 = pth.join(dir, file);
+          const stat = self.fs.statSync(path13);
+          if (!pattern || pattern.test(path13)) {
+            files.push(pth.normalize(path13) + (stat.isDirectory() ? self.sep : ""));
           }
           if (stat.isDirectory() && recursive) {
-            const realDir = self.fs.realpathSync(path12);
+            const realDir = self.fs.realpathSync(path13);
             if (!visited.has(realDir)) {
               visited.add(realDir);
-              files = files.concat(findSync(path12, pattern, recursive, visited));
+              files = files.concat(findSync(path13, pattern, recursive, visited));
             }
           }
         });
         return files;
       }
-      return findSync(path11, void 0, true, /* @__PURE__ */ new Set([self.fs.realpathSync(path11)]));
+      return findSync(path12, void 0, true, /* @__PURE__ */ new Set([self.fs.realpathSync(path12)]));
     };
     Utils.prototype.findFilesAsync = function(dir, cb) {
       const self = this;
@@ -539,14 +539,14 @@ var require_utils = __commonJS({
           return "UNSUPPORTED (" + method + ")";
       }
     };
-    Utils.canonical = function(path11) {
-      if (!path11) return "";
-      const safeSuffix = pth.posix.normalize("/" + path11.split("\\").join("/"));
+    Utils.canonical = function(path12) {
+      if (!path12) return "";
+      const safeSuffix = pth.posix.normalize("/" + path12.split("\\").join("/"));
       return pth.join(".", safeSuffix);
     };
-    Utils.zipnamefix = function(path11) {
-      if (!path11) return "";
-      const safeSuffix = pth.posix.normalize("/" + path11.split("\\").join("/"));
+    Utils.zipnamefix = function(path12) {
+      if (!path12) return "";
+      const safeSuffix = pth.posix.normalize("/" + path12.split("\\").join("/"));
       return pth.posix.join(".", safeSuffix);
     };
     Utils.findLast = function(arr, callback) {
@@ -563,9 +563,9 @@ var require_utils = __commonJS({
       prefix = pth.resolve(pth.normalize(prefix));
       var parts = name.split("/");
       for (var i = 0, l = parts.length; i < l; i++) {
-        var path11 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
-        if (path11 === prefix || path11.startsWith(prefix + pth.sep)) {
-          return path11;
+        var path12 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
+        if (path12 === prefix || path12.startsWith(prefix + pth.sep)) {
+          return path12;
         }
       }
       return pth.normalize(pth.join(prefix, pth.basename(name)));
@@ -611,8 +611,8 @@ var require_utils = __commonJS({
 var require_fattr = __commonJS({
   "node_modules/adm-zip/util/fattr.js"(exports, module) {
     var pth = __require("path");
-    module.exports = function(path11, { fs: fs9 }) {
-      var _path = path11 || "", _obj = newAttr(), _stat = null;
+    module.exports = function(path12, { fs: fs10 }) {
+      var _path = path12 || "", _obj = newAttr(), _stat = null;
       function newAttr() {
         return {
           directory: false,
@@ -623,8 +623,8 @@ var require_fattr = __commonJS({
           atime: 0
         };
       }
-      if (_path && fs9.existsSync(_path)) {
-        _stat = fs9.statSync(_path);
+      if (_path && fs10.existsSync(_path)) {
+        _stat = fs10.statSync(_path);
         _obj.directory = _stat.isDirectory();
         _obj.mtime = _stat.mtime;
         _obj.atime = _stat.atime;
@@ -2750,8 +2750,8 @@ var require_adm_zip = __commonJS({
 });
 
 // src/index.ts
-import fs8 from "node:fs";
-import path10 from "node:path";
+import fs9 from "node:fs";
+import path11 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import os4 from "node:os";
 
@@ -3094,6 +3094,25 @@ var SkillUpdater = class {
     }
     return void 0;
   }
+  /** 在解压目录里定位专家根目录；专家包根必须同时包含 AGENTS.md 和 SOUL.md。 */
+  async locateExpertRoot(dir, depth) {
+    if (depth > 2) return void 0;
+    let entries;
+    try {
+      entries = await fs3.readdir(dir, { withFileTypes: true });
+    } catch {
+      return void 0;
+    }
+    const files = new Set(entries.filter((entry) => entry.isFile()).map((entry) => entry.name));
+    if (files.has("AGENTS.md") && files.has("SOUL.md")) return dir;
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const found = await this.locateExpertRoot(path3.join(dir, entry.name), depth + 1);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  }
   /**
    * 直接覆盖、不备份，但保证「不丢数据」：
    *   先把新内容暂存到同级临时目录 → 旧目录改名挪开 → 新内容 rename 换入 → 删掉挪开的旧目录。
@@ -3157,6 +3176,29 @@ var SkillUpdater = class {
       });
     }
   }
+  async installExpertZipFromUrl(url, targetDir) {
+    const work = path3.join(this.tmpDir, `slp-expert-${randomUUID()}`);
+    await fs3.mkdir(work, { recursive: true });
+    try {
+      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}` };
+      await fs3.writeFile(zipPath, Buffer.from(await res.arrayBuffer()));
+      const staging = path3.join(work, "staging");
+      await this.unzip(zipPath, staging);
+      const expertRoot = await this.locateExpertRoot(staging, 0);
+      if (!expertRoot) {
+        return { success: false, message: "\u4E0B\u8F7D\u5305\u5185\u672A\u627E\u5230\u540C\u65F6\u542B AGENTS.md \u548C SOUL.md \u7684\u4E13\u5BB6\u6839\u76EE\u5F55" };
+      }
+      await this.replaceDir(expertRoot, targetDir);
+      return { success: true, message: "\u5B89\u88C5\u6210\u529F" };
+    } catch (err) {
+      return { success: false, message: `\u6267\u884C\u51FA\u9519: ${err.message}` };
+    } finally {
+      await fs3.rm(work, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
   async manualInstall(options) {
     const { code, force, targetDir, additionalTargetDirs = [], trace } = options;
     let { url, version } = options;
@@ -3178,6 +3220,11 @@ var SkillUpdater = class {
       targetCount: 1 + additionalTargetDirs.length
     });
     try {
+      if (!code || code === "." || code === ".." || code.includes("/") || code.includes("\\") || code.includes("\0") || path3.basename(code) !== code) {
+        const message = `\u975E\u6CD5\u7684 Skill code: ${code}`;
+        emit("install.failed", { stage: currentStage, message, elapsedMs: Date.now() - startedAt });
+        return { success: false, message };
+      }
       if (!url) {
         const lookupStartedAt = Date.now();
         emit("download_url.lookup.start", { code, version: version || "latest" });
@@ -3658,6 +3705,9 @@ function parseCore(v) {
   }
   return nums.length > 0 ? nums : null;
 }
+function isComparableVersion(v) {
+  return parseCore(v) !== null;
+}
 function compareVersions(a, b) {
   const na = parseCore(a);
   const nb = parseCore(b);
@@ -4395,35 +4445,284 @@ var Reporter = class {
   }
 };
 
+// src/expert-skill-layout.ts
+import fs7 from "node:fs/promises";
+import path8 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var ASSISTANT_WORKSPACE_RE = /^workspace-assistant-\d{5,}$/;
+var REPAIR_RESIDUE_RE = /^\.(.+)\.repair-(old|new)-(.+)$/;
+async function lstatOrUndefined(filePath) {
+  try {
+    return await fs7.lstat(filePath);
+  } catch (error) {
+    if (error?.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function isRegularFile(filePath) {
+  const stat = await lstatOrUndefined(filePath);
+  return Boolean(stat?.isFile() && !stat.isSymbolicLink());
+}
+async function removeRealDirectory(dirPath) {
+  const stat = await lstatOrUndefined(dirPath);
+  if (!stat) return;
+  if (stat.isSymbolicLink() || !stat.isDirectory()) {
+    throw new Error(`\u62D2\u7EDD\u6E05\u7406\u975E\u771F\u5B9E\u76EE\u5F55: ${dirPath}`);
+  }
+  await fs7.rm(dirPath, { recursive: true });
+}
+async function removeNestedDirectoryIfPresent(dirPath) {
+  const stat = await lstatOrUndefined(dirPath);
+  if (!stat) return;
+  if (stat.isSymbolicLink()) throw new Error(`\u62D2\u7EDD\u6E05\u7406\u7B26\u53F7\u94FE\u63A5: ${dirPath}`);
+  if (stat.isDirectory()) await fs7.rm(dirPath, { recursive: true });
+}
+async function recoverRepairResidues(skillsRoot, entries, result) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const match2 = REPAIR_RESIDUE_RE.exec(entry.name);
+    if (!match2) continue;
+    const group = groups.get(match2[1]) ?? { old: [], stage: [] };
+    group[match2[2] === "old" ? "old" : "stage"].push(path8.join(skillsRoot, entry.name));
+    groups.set(match2[1], group);
+  }
+  for (const [code, group] of groups) {
+    const targetDir = path8.join(skillsRoot, code);
+    try {
+      const targetStat = await lstatOrUndefined(targetDir);
+      if (targetStat?.isSymbolicLink() || targetStat && !targetStat.isDirectory()) {
+        throw new Error(`\u89C4\u8303\u8DEF\u5F84\u4E0D\u662F\u53EF\u5B89\u5168\u64CD\u4F5C\u7684\u771F\u5B9E\u76EE\u5F55: ${targetDir}`);
+      }
+      group.old.sort().reverse();
+      if (!targetStat && group.old.length > 0) {
+        const restore = group.old.shift();
+        const restoreStat = await lstatOrUndefined(restore);
+        if (!restoreStat?.isDirectory() || restoreStat.isSymbolicLink()) {
+          throw new Error(`\u62D2\u7EDD\u4ECE\u975E\u771F\u5B9E\u76EE\u5F55\u6062\u590D: ${restore}`);
+        }
+        await fs7.rename(restore, targetDir);
+      }
+      if (await lstatOrUndefined(targetDir)) {
+        for (const residue of [...group.old, ...group.stage]) {
+          await removeRealDirectory(residue);
+        }
+      }
+    } catch (error) {
+      result.errors.push({ path: targetDir, message: error?.message || String(error) });
+    }
+  }
+}
+async function promoteNestedSkill(sourceDir, targetDir) {
+  const parent = path8.dirname(targetDir);
+  const tag = `${Date.now()}-${randomUUID2().slice(0, 8)}`;
+  const stage = path8.join(parent, `.${path8.basename(targetDir)}.repair-new-${tag}`);
+  const old = path8.join(parent, `.${path8.basename(targetDir)}.repair-old-${tag}`);
+  let movedOld = false;
+  try {
+    await fs7.cp(sourceDir, stage, { recursive: true });
+    await removeNestedDirectoryIfPresent(path8.join(stage, path8.basename(targetDir)));
+    await fs7.rename(targetDir, old);
+    movedOld = true;
+    await fs7.rename(stage, targetDir);
+  } catch (error) {
+    const rollbackErrors = [];
+    try {
+      await removeRealDirectory(stage);
+    } catch (cleanupError) {
+      rollbackErrors.push(`\u6E05\u7406\u6682\u5B58\u76EE\u5F55\u5931\u8D25: ${cleanupError?.message || String(cleanupError)}`);
+    }
+    if (movedOld) {
+      try {
+        await fs7.rename(old, targetDir);
+      } catch (restoreError) {
+        rollbackErrors.push(`\u6062\u590D\u65E7\u76EE\u5F55\u5931\u8D25: ${restoreError?.message || String(restoreError)}`);
+      }
+    }
+    if (rollbackErrors.length > 0) {
+      throw new Error(`${error?.message || String(error)}; ${rollbackErrors.join("; ")}`);
+    }
+    throw error;
+  }
+  await removeRealDirectory(old);
+}
+async function repairNestedExpertSkillLayouts(openclawRoot) {
+  const result = {
+    scannedWorkspaces: 0,
+    repaired: [],
+    skipped: [],
+    errors: []
+  };
+  let workspaceEntries;
+  try {
+    workspaceEntries = await fs7.readdir(openclawRoot, { withFileTypes: true });
+  } catch (error) {
+    result.errors.push({ path: openclawRoot, message: error?.message || String(error) });
+    return result;
+  }
+  for (const workspaceEntry of workspaceEntries) {
+    if (!workspaceEntry.isDirectory() || !ASSISTANT_WORKSPACE_RE.test(workspaceEntry.name)) continue;
+    result.scannedWorkspaces += 1;
+    const skillsRoot = path8.join(openclawRoot, workspaceEntry.name, ".user", "skills");
+    let skillEntries;
+    try {
+      skillEntries = await fs7.readdir(skillsRoot, { withFileTypes: true });
+      await recoverRepairResidues(skillsRoot, skillEntries, result);
+      skillEntries = await fs7.readdir(skillsRoot, { withFileTypes: true });
+    } catch (error) {
+      if (error?.code !== "ENOENT") {
+        result.errors.push({ path: skillsRoot, message: error?.message || String(error) });
+      }
+      continue;
+    }
+    for (const skillEntry of skillEntries) {
+      if (!skillEntry.isDirectory() || skillEntry.name.startsWith(".")) continue;
+      const outerDir = path8.join(skillsRoot, skillEntry.name);
+      try {
+        const candidates = [];
+        const outerHasSkill = await isRegularFile(path8.join(outerDir, "SKILL.md"));
+        if (outerHasSkill) {
+          const version = await readSkillVersion(outerDir);
+          if (!version) {
+            result.skipped.push(outerDir);
+            continue;
+          }
+          candidates.push({ dir: outerDir, version });
+        }
+        let cursor = outerDir;
+        let nestedCount = 0;
+        while (true) {
+          const nestedDir = path8.join(cursor, skillEntry.name);
+          const nestedStat = await lstatOrUndefined(nestedDir);
+          if (!nestedStat) break;
+          if (nestedStat.isSymbolicLink()) {
+            throw new Error(`\u62D2\u7EDD\u8DDF\u968F\u540C\u540D\u7B26\u53F7\u94FE\u63A5: ${nestedDir}`);
+          }
+          if (!nestedStat.isDirectory()) break;
+          cursor = nestedDir;
+          const skillMd = path8.join(nestedDir, "SKILL.md");
+          const skillStat = await lstatOrUndefined(skillMd);
+          if (skillStat?.isSymbolicLink()) {
+            throw new Error(`\u62D2\u7EDD\u8BFB\u53D6\u7B26\u53F7\u94FE\u63A5 SKILL.md: ${skillMd}`);
+          }
+          if (!skillStat?.isFile()) continue;
+          nestedCount += 1;
+          const version = await readSkillVersion(nestedDir);
+          if (!version) {
+            result.skipped.push(outerDir);
+            candidates.length = 0;
+            break;
+          }
+          candidates.push({ dir: nestedDir, version });
+        }
+        if (nestedCount === 0 || candidates.length === 0) continue;
+        if (candidates.some((candidate) => !isComparableVersion(candidate.version))) {
+          result.skipped.push(outerDir);
+          continue;
+        }
+        let source = candidates[0];
+        for (const candidate of candidates.slice(1)) {
+          if (compareVersions(candidate.version, source.version) >= 0) source = candidate;
+        }
+        if (source.dir === outerDir) {
+          result.skipped.push(outerDir);
+          continue;
+        }
+        await promoteNestedSkill(source.dir, outerDir);
+        result.repaired.push(outerDir);
+      } catch (error) {
+        result.errors.push({ path: outerDir, message: error?.message || String(error) });
+      }
+    }
+  }
+  return result;
+}
+
 // src/ws-client.ts
 import WebSocket from "ws";
-import path8 from "path";
-import fs7 from "fs/promises";
+import path9 from "path";
+import fs8 from "fs/promises";
 import { DatabaseSync } from "node:sqlite";
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var HEARTBEAT_ACK_TIMEOUT_MS = 75e3;
 var AGENT_SCAN_INTERVAL_MS = 3 * 60 * 1e3;
-var ASSISTANT_WORKSPACE_PREFIX = "workspace-assistant-";
 var ASSISTANT_AGENT_PREFIX = "assistant-";
 var ASSISTANT_WORKSPACE_ID_RE = /^\d{5,}$/;
-function parseAssistantWorkspaceAgentId(entryName) {
-  if (!entryName.startsWith(ASSISTANT_WORKSPACE_PREFIX)) return void 0;
-  const suffix = entryName.slice(ASSISTANT_WORKSPACE_PREFIX.length);
-  if (!ASSISTANT_WORKSPACE_ID_RE.test(suffix)) return void 0;
-  return `${ASSISTANT_AGENT_PREFIX}${suffix}`;
+function enabledAgentIdsFromAccounts(config) {
+  if (!config || typeof config !== "object") return [];
+  const channels = config.channels;
+  if (!channels || typeof channels !== "object") return [];
+  const cworkConfig = channels.xg_cwork_im;
+  if (!cworkConfig || typeof cworkConfig !== "object") return [];
+  const accounts = cworkConfig.accounts;
+  if (!accounts || typeof accounts !== "object" || Array.isArray(accounts)) return [];
+  const agentIds = /* @__PURE__ */ new Set();
+  for (const account of Object.values(accounts)) {
+    if (!account || typeof account !== "object" || account.enabled === false) continue;
+    if (typeof account.agentId !== "string") continue;
+    const agentId = account.agentId.trim();
+    if (agentId) agentIds.add(agentId);
+  }
+  return [...agentIds];
+}
+function resolveSkillInstallTarget(config, userId) {
+  if (!config || typeof config !== "object") throw new Error("openclaw.json \u914D\u7F6E\u65E0\u6548");
+  const root = config;
+  const accounts = root.channels?.xg_cwork_im?.accounts;
+  if (!accounts || typeof accounts !== "object" || Array.isArray(accounts)) {
+    throw new Error(`\u672A\u627E\u5230 userId=${userId} \u7684 xg_cwork_im account`);
+  }
+  const matched = Object.entries(accounts).filter(([, account2]) => account2 && typeof account2 === "object" && account2.agentId === userId);
+  if (matched.length !== 1) {
+    throw new Error(matched.length > 1 ? `userId=${userId} \u5B58\u5728\u591A\u4E2A xg_cwork_im account\uFF0C\u65E0\u6CD5\u786E\u5B9A\u5B89\u88C5\u76EE\u5F55` : `\u672A\u627E\u5230 userId=${userId} \u7684 xg_cwork_im account`);
+  }
+  const [accountId, account] = matched[0];
+  if (account.enabled === false) throw new Error(`userId=${userId} \u5BF9\u5E94 Agent \u5DF2\u7981\u7528`);
+  const bindingAccountIds = /* @__PURE__ */ new Set([accountId, userId]);
+  const bindings = Array.isArray(root.bindings) ? root.bindings : [];
+  const binding = bindings.find((item) => {
+    if (!item || typeof item !== "object") return false;
+    const candidate = item;
+    return candidate.match?.channel === "xg_cwork_im" && typeof candidate.match.accountId === "string" && bindingAccountIds.has(candidate.match.accountId) && typeof candidate.agentId === "string" && candidate.agentId.length > 0;
+  });
+  const localAgentId = typeof binding?.agentId === "string" ? binding.agentId : userId;
+  const list = Array.isArray(root.agents?.list) ? root.agents.list : [];
+  const agent = list.find(
+    (item) => Boolean(item) && typeof item === "object" && item.id === localAgentId
+  );
+  if (!agent) throw new Error(`\u672A\u627E\u5230\u672C\u5730 Agent \u914D\u7F6E: ${localAgentId}`);
+  const workspace = typeof agent.workspace === "string" ? agent.workspace : root.agents?.defaults?.workspace;
+  if (typeof workspace !== "string" || !workspace.trim()) {
+    throw new Error(`\u672C\u5730 Agent ${localAgentId} \u672A\u914D\u7F6E workspace`);
+  }
+  return { skillsDir: path9.join(workspace, "skills"), localAgentId };
 }
 function normalizeAssistantUserId(userId) {
-  const safeUserId = path8.basename(userId);
+  const safeUserId = path9.basename(userId);
   if (safeUserId !== userId) return void 0;
   const pureId = safeUserId.startsWith(ASSISTANT_AGENT_PREFIX) ? safeUserId.slice(ASSISTANT_AGENT_PREFIX.length) : safeUserId;
   if (!ASSISTANT_WORKSPACE_ID_RE.test(pureId)) return void 0;
   return pureId;
 }
+function normalizeCommandCode(code) {
+  if (typeof code !== "string" || code.length === 0 || code === "." || code === "..") return void 0;
+  if (code.includes("/") || code.includes("\\") || code.includes("\0")) return void 0;
+  if (path9.basename(code) !== code) return void 0;
+  return code;
+}
 function shouldSyncBuiltInTemplate(action, isBuiltIn) {
   return action === "UPDATE_SKILL" && isBuiltIn === true;
 }
+async function findInstalledExpertSkillsRoot(rootPath, pureId, code) {
+  const skillsRoot = path9.join(rootPath, `workspace-assistant-${pureId}`, ".user", "skills");
+  try {
+    const stat = await fs8.stat(path9.join(skillsRoot, code));
+    return stat.isDirectory() ? skillsRoot : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function defaultOpenclawSqlitePath() {
-  return path8.join(openclawHome(), "state", "openclaw.sqlite");
+  return path9.join(openclawHome(), "state", "openclaw.sqlite");
 }
 function readCronJobsByAgentId(agentId, sqlitePath = defaultOpenclawSqlitePath(), onError) {
   let db;
@@ -4463,10 +4762,10 @@ var GatewayWsClient = class {
         }
       }
       logLine += "\n";
-      const logsDir = path8.join(openclawHome(), "logs");
-      fs7.mkdir(logsDir, { recursive: true }).then(() => {
-        const logPath = path8.join(logsDir, "skill-logger.err");
-        fs7.appendFile(logPath, logLine).catch(() => {
+      const logsDir = path9.join(openclawHome(), "logs");
+      fs8.mkdir(logsDir, { recursive: true }).then(() => {
+        const logPath = path9.join(logsDir, "skill-logger.err");
+        fs8.appendFile(logPath, logLine).catch(() => {
         });
       }).catch(() => {
       });
@@ -4481,6 +4780,17 @@ var GatewayWsClient = class {
       });
     };
   }
+  /** 普通 Skill 的所有读写操作共用这一个配置驱动的寻址入口。 */
+  async resolveRegularSkillTarget(userId) {
+    const configPath = path9.join(openclawHome(), "openclaw.json");
+    let config;
+    try {
+      config = JSON.parse(await fs8.readFile(configPath, "utf-8"));
+    } catch (err) {
+      throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 openclaw.json: ${err?.message || String(err)}`);
+    }
+    return resolveSkillInstallTarget(config, userId).skillsDir;
+  }
   constructor(options) {
     this.options = options;
   }
@@ -4576,26 +4886,26 @@ var GatewayWsClient = class {
       }
     });
   }
-  /**
-   * 扫描 OpenClaw 根目录下的 workspace-assistant-{userId} 目录。
-   * userId 必须是至少 5 位数字。
-   */
+  /** 从 openclaw.json 的 xg_cwork_im accounts 读取当前启用的 agent。 */
   async scanAndReportAgents(isInitialReport) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     try {
-      const rootPath = openclawHome();
-      let entries = [];
+      const configPath = path9.join(openclawHome(), "openclaw.json");
+      let rawConfig;
       try {
-        entries = await fs7.readdir(rootPath);
+        rawConfig = await fs8.readFile(configPath, "utf-8");
       } catch (e) {
-        this.appendLogToFile("WARN", "AgentScan", "OpenClaw home is not readable; skipping this scan cycle", e);
+        this.appendLogToFile("WARN", "AgentScan", "OpenClaw config is not readable; skipping this scan cycle", e);
         return;
       }
-      const newAgentIds = /* @__PURE__ */ new Set();
-      for (const entry of entries) {
-        const agentId = parseAssistantWorkspaceAgentId(entry);
-        if (agentId) newAgentIds.add(agentId);
+      let config;
+      try {
+        config = JSON.parse(rawConfig);
+      } catch (e) {
+        this.appendLogToFile("WARN", "AgentScan", "OpenClaw config is invalid JSON; skipping this scan cycle", e);
+        return;
       }
+      const newAgentIds = new Set(enabledAgentIdsFromAccounts(config));
       let changed = false;
       if (newAgentIds.size !== this.currentAgentIds.size) {
         changed = true;
@@ -4747,7 +5057,7 @@ var GatewayWsClient = class {
       return;
     }
     if (action === "GET_CRON_JOBS_BY_AGENT_ID") {
-      const agentId = typeof msg.agent_id === "string" ? msg.agent_id : msg.agentId;
+      const agentId = typeof msg.agent_id === "string" ? msg.agent_id : typeof msg.agentId === "string" ? msg.agentId : userId;
       if (!agentId) {
         this.reply(replyId, { success: false, message: "Missing agent_id parameter", action });
         return;
@@ -4767,16 +5077,20 @@ var GatewayWsClient = class {
       this.appendLogToFile("WARN", "Command", `Message dropped: missing userId`, msg);
       return;
     }
-    const safeCode = code ? path8.basename(code) : void 0;
+    const safeCode = normalizeCommandCode(code);
+    if (code !== void 0 && !safeCode) {
+      this.reply(replyId, { success: false, message: `Invalid code: ${String(code)}`, action });
+      return;
+    }
     const pureId = normalizeAssistantUserId(userId);
     if (!pureId) {
       this.reply(replyId, { success: false, message: `Invalid userId: ${userId}`, action });
       return;
     }
-    const targetDir = path8.join(openclawHome(), `workspace-assistant-${pureId}`, "skills");
     try {
       if (action === "INSTALL_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
+        const targetDir = await this.resolveRegularSkillTarget(userId);
         console.log(`[skill-logger-plugin][WS] Executing INSTALL for user ${userId}, code: ${safeCode}`);
         this.appendLogToFile("INFO", "Command", `INSTALL_SKILL received`, { userId, code: safeCode, version });
         const result = await this.options.updater.manualInstall({
@@ -4790,16 +5104,18 @@ var GatewayWsClient = class {
         this.reply(replyId, { success: result.success, message: result.message, action });
       } else if (action === "UNINSTALL_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
+        const targetDir = await this.resolveRegularSkillTarget(userId);
         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 = path8.join(targetDir, safeCode);
-        await fs7.rm(skillPath, { recursive: true, force: true });
+        const skillPath = path9.join(targetDir, safeCode);
+        await fs8.rm(skillPath, { recursive: true, force: true });
         this.reply(replyId, { success: true, message: `Skill ${safeCode} removed`, action });
       } else if (action === "LIST_SKILLS") {
+        const targetDir = await this.resolveRegularSkillTarget(userId);
         let list = [];
         let targetDirExists = false;
         try {
-          const targetStat = await fs7.stat(targetDir);
+          const targetStat = await fs8.stat(targetDir);
           targetDirExists = targetStat.isDirectory();
         } catch (err) {
           if (err?.code !== "ENOENT") throw err;
@@ -4807,18 +5123,18 @@ var GatewayWsClient = class {
         if (!targetDirExists) {
           throw new Error(`Target skills directory does not exist: ${targetDir}`);
         }
-        const entries = await fs7.readdir(targetDir, { withFileTypes: true });
+        const entries = await fs8.readdir(targetDir, { withFileTypes: true });
         const dirs = entries.filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !e.name.startsWith("."));
         for (const e of dirs) {
-          const skillDir = path8.join(targetDir, e.name);
-          const skillMdPath = path8.join(skillDir, "SKILL.md");
+          const skillDir = path9.join(targetDir, e.name);
+          const skillMdPath = path9.join(skillDir, "SKILL.md");
           try {
-            const stat = await fs7.stat(skillMdPath);
+            const stat = await fs8.stat(skillMdPath);
             if (!stat.isFile()) continue;
           } catch (err) {
             continue;
           }
-          const metaPath = path8.join(skillDir, ".meta.json");
+          const metaPath = path9.join(skillDir, ".meta.json");
           let isPlatform = false;
           let isBuiltIn2 = e.isSymbolicLink();
           let metaData = null;
@@ -4826,7 +5142,7 @@ var GatewayWsClient = class {
           let description = "";
           let skillVersion = "";
           try {
-            const mdContent = await fs7.readFile(skillMdPath, "utf8");
+            const mdContent = await fs8.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;
@@ -4837,7 +5153,7 @@ var GatewayWsClient = class {
           } catch (err) {
           }
           try {
-            const metaContent = await fs7.readFile(metaPath, "utf8");
+            const metaContent = await fs8.readFile(metaPath, "utf8");
             const parsed = JSON.parse(metaContent);
             if (parsed) {
               if (parsed.ownerId === "CMS" || parsed.ownerId === "CMS_COMPAT") isPlatform = true;
@@ -4885,13 +5201,10 @@ var GatewayWsClient = class {
         });
         setTimeout(async () => {
           try {
-            const additionalTargetDirs = syncBuiltInTemplate ? [path8.join(openclawHome(), "workspace-xgjk-assistant-template", "skills")] : [];
-            const userSkillDir = path8.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "skills", safeCode);
-            try {
-              await fs7.stat(userSkillDir);
-              additionalTargetDirs.push(userSkillDir);
-            } catch {
-            }
+            const targetDir = await this.resolveRegularSkillTarget(userId);
+            const additionalTargetDirs = syncBuiltInTemplate ? [path9.join(openclawHome(), "workspace-xgjk-assistant-template", "skills")] : [];
+            const userSkillRoot = await findInstalledExpertSkillsRoot(openclawHome(), pureId, safeCode);
+            if (userSkillRoot) additionalTargetDirs.push(userSkillRoot);
             const result = await this.options.updater.manualInstall({
               code: safeCode,
               url,
@@ -4935,12 +5248,12 @@ var GatewayWsClient = class {
         const { name, version: version2, downloadUrl, skills } = msg;
         console.log(`[skill-logger-plugin][WS] Executing INSTALL_EXPERT for user ${userId}, code: ${safeCode}`);
         this.appendLogToFile("INFO", "Command", `INSTALL_EXPERT received`, { userId, code: safeCode, version: version2, downloadUrl });
-        const userSkillRoot = path8.join(openclawHome(), `workspace-assistant-${pureId}`, ".user");
-        const expertTarget = path8.join(userSkillRoot, "experts", safeCode);
+        const userSkillRoot = path9.join(openclawHome(), `workspace-assistant-${pureId}`, ".user");
+        const expertTarget = path9.join(userSkillRoot, "experts", safeCode);
         let skipInstall = false;
-        const metaPath = path8.join(expertTarget, ".meta.json");
+        const metaPath = path9.join(expertTarget, ".meta.json");
         try {
-          const raw = await fs7.readFile(metaPath, "utf-8");
+          const raw = await fs8.readFile(metaPath, "utf-8");
           const existing = JSON.parse(raw);
           if (existing.version && existing.version === (version2 || "1.0.0")) {
             skipInstall = true;
@@ -4948,29 +5261,39 @@ var GatewayWsClient = class {
         } catch {
         }
         if (!skipInstall) {
-          await fs7.mkdir(path8.dirname(expertTarget), { recursive: true });
-          const expertResult = await this.options.updater.installZipFromUrl(downloadUrl, expertTarget);
+          await fs8.mkdir(path9.dirname(expertTarget), { recursive: true });
+          const expertResult = await this.options.updater.installExpertZipFromUrl(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 fs7.writeFile(metaPath, JSON.stringify(meta, null, 2));
-        const skillTargetRoot = path8.join(userSkillRoot, "skills");
-        await fs7.mkdir(skillTargetRoot, { recursive: true });
+        await fs8.writeFile(metaPath, JSON.stringify(meta, null, 2));
+        const skillTargetRoot = path9.join(userSkillRoot, "skills");
+        await fs8.mkdir(skillTargetRoot, { recursive: true });
         const skillResults = [];
         if (Array.isArray(skills)) {
           for (const sk of skills) {
-            if (!sk.code || !sk.downloadUrl) {
-              skillResults.push(`${sk.code || "unknown"}: \u7F3A\u5C11\u4E0B\u8F7D\u5730\u5740`);
+            const skillCode = normalizeCommandCode(sk?.code);
+            if (!skillCode) {
+              skillResults.push(`${String(sk?.code || "unknown")}: \u5931\u8D25 - \u975E\u6CD5\u7684 Skill code`);
+              continue;
+            }
+            if (!sk.downloadUrl) {
+              skillResults.push(`${skillCode}: \u5931\u8D25 - \u7F3A\u5C11\u4E0B\u8F7D\u5730\u5740`);
               continue;
             }
             try {
-              const skTarget = path8.join(skillTargetRoot, sk.code);
-              const result = await this.options.updater.installZipFromUrl(sk.downloadUrl, skTarget);
-              skillResults.push(`${sk.code}: ${result.success ? "\u6210\u529F" : "\u5931\u8D25 - " + result.message}`);
+              const result = await this.options.updater.manualInstall({
+                code: skillCode,
+                url: sk.downloadUrl,
+                version: sk.version,
+                force: true,
+                targetDir: skillTargetRoot
+              });
+              skillResults.push(`${skillCode}: ${result.success ? "\u6210\u529F" : "\u5931\u8D25 - " + result.message}`);
             } catch (e) {
-              skillResults.push(`${sk.code}: \u5931\u8D25 - ${e.message}`);
+              skillResults.push(`${skillCode}: \u5931\u8D25 - ${e.message}`);
             }
           }
         }
@@ -4984,23 +5307,23 @@ var GatewayWsClient = class {
         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 = path8.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts", safeCode);
-        await fs7.rm(expertPath, { recursive: true, force: true });
+        const expertPath = path9.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts", safeCode);
+        await fs8.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 = path8.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts");
+        const expertsDir = path9.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts");
         const list = [];
         try {
-          const stat = await fs7.stat(expertsDir);
+          const stat = await fs8.stat(expertsDir);
           if (stat.isDirectory()) {
-            const entries = await fs7.readdir(expertsDir, { withFileTypes: true });
+            const entries = await fs8.readdir(expertsDir, { withFileTypes: true });
             for (const e of entries) {
               if (!e.isDirectory()) continue;
-              const metaPath = path8.join(expertsDir, e.name, ".meta.json");
+              const metaPath = path9.join(expertsDir, e.name, ".meta.json");
               try {
-                const raw = await fs7.readFile(metaPath, "utf-8");
+                const raw = await fs8.readFile(metaPath, "utf-8");
                 const meta = JSON.parse(raw);
                 list.push({
                   code: meta.code || e.name,
@@ -5054,8 +5377,8 @@ var GatewayWsClient = class {
 };
 
 // src/hooks.ts
-import path9 from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import path10 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 var PENDING_TTL_MS = 30 * 60 * 1e3;
 var PENDING_MAX = 5e3;
 function toMySQLDateTime(d) {
@@ -5063,7 +5386,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 path9.basename(filePath) === "SKILL.md";
+  return path10.basename(filePath) === "SKILL.md";
 }
 function extractAppKey(event, ctx) {
   try {
@@ -5173,7 +5496,7 @@ var Hooks = class {
   }
   buildPendingEvent(p, status, error, durationMs, appKey) {
     return {
-      event_id: randomUUID2(),
+      event_id: randomUUID3(),
       event_type: "function_call",
       skill_name: p.skillName,
       skill_version: p.skillVersion,
@@ -5243,8 +5566,8 @@ var Hooks = class {
       if (toolName === "read") {
         const filePath = params.path ?? params.file_path ?? "";
         if (!isSkillMdReadPath(filePath)) return;
-        const rootDir = path9.dirname(filePath);
-        const skillName = this.configSync.resolveSkillName(rootDir) || path9.basename(rootDir);
+        const rootDir = path10.dirname(filePath);
+        const skillName = this.configSync.resolveSkillName(rootDir) || path10.basename(rootDir);
         if (!skillName) return;
         this.debug(`Intercepted 'read' for SKILL.md. Attributed to skill: ${skillName}`);
         this.recordTrigger(skillName, "inline", "read", ctx, appKey);
@@ -5329,7 +5652,7 @@ var Hooks = class {
   /** 记 skill 触发事件 + 标记激活 + 懒拉配置。 */
   recordTrigger(skillName, invokeMode, invokeTool, ctx, appKey) {
     this.emit({
-      event_id: randomUUID2(),
+      event_id: randomUUID3(),
       event_type: "skill_trigger",
       skill_name: skillName,
       skill_version: this.configSync.getVersion(skillName),
@@ -5349,7 +5672,7 @@ var Hooks = class {
   }
   buildFunctionCall(res, command, invokeTool, status, error, durationMs, ctx, appKey) {
     return {
-      event_id: randomUUID2(),
+      event_id: randomUUID3(),
       event_type: "function_call",
       skill_name: res.skillName,
       skill_version: res.skillVersion,
@@ -5391,7 +5714,7 @@ var Hooks = class {
       return;
     }
     this.emit({
-      event_id: randomUUID2(),
+      event_id: randomUUID3(),
       event_type: "function_call",
       skill_name: skillName,
       match_type: void 0,
@@ -5444,9 +5767,9 @@ var definition = {
   register(api) {
     let pkgVersion = "unknown";
     try {
-      const dir = path10.dirname(fileURLToPath2(import.meta.url));
-      const pkgPath = path10.join(dir, "..", "package.json");
-      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+      const dir = path11.dirname(fileURLToPath2(import.meta.url));
+      const pkgPath = path11.join(dir, "..", "package.json");
+      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
       if (pkg.version) pkgVersion = pkg.version;
     } catch {
     }
@@ -5463,6 +5786,25 @@ var definition = {
     const configSync = new ConfigSync({ paths, getConfig, updater });
     const reporter = new Reporter({ paths, getConfig });
     const hooks = new Hooks(reporter, configSync, activeSkills, getConfig);
+    let expertSkillLayoutRepair;
+    const repairExpertSkillLayouts = () => {
+      if (expertSkillLayoutRepair) return expertSkillLayoutRepair;
+      expertSkillLayoutRepair = (async () => {
+        const result = await repairNestedExpertSkillLayouts(openclawHome());
+        if (result.repaired.length > 0) {
+          console.log(`[skill-logger-plugin] \u5DF2\u4FEE\u590D ${result.repaired.length} \u4E2A\u4E13\u5BB6 Skill \u5D4C\u5957\u76EE\u5F55`);
+        }
+        for (const skippedPath of result.skipped) {
+          console.warn(`[skill-logger-plugin] \u4E13\u5BB6 Skill \u5D4C\u5957\u76EE\u5F55\u7248\u672C\u65E0\u6CD5\u5B89\u5168\u63D0\u5347\uFF0C\u5DF2\u4FDD\u7559\u73B0\u573A: ${skippedPath}`);
+        }
+        for (const error of result.errors) {
+          console.warn(`[skill-logger-plugin] \u4FEE\u590D\u4E13\u5BB6 Skill \u76EE\u5F55\u5931\u8D25: ${error.path}`, error.message);
+        }
+      })().finally(() => {
+        expertSkillLayoutRepair = void 0;
+      });
+      return expertSkillLayoutRepair;
+    };
     let reconcileTimer;
     const sessionUpdatedSkills = /* @__PURE__ */ new Set();
     api.on("message_received", (event, ctx) => {
@@ -5513,9 +5855,8 @@ var definition = {
           enableFileLog: currentConfig2.enableFileLog
           // 将日志开关透传给客户端模块
         });
-        wsClient.connect();
       }
-      void configSync.load().then(() => configSync.reconcile()).catch((err) => console.warn("[skill-logger-plugin] \u542F\u52A8\u521D\u59CB\u5316\u5F02\u5E38", err));
+      void repairExpertSkillLayouts().then(() => wsClient?.connect()).then(() => configSync.load()).then(() => configSync.reconcile()).catch((err) => console.warn("[skill-logger-plugin] \u542F\u52A8\u521D\u59CB\u5316\u5F02\u5E38", err));
       reporter.startTimer();
       if (!reconcileTimer) {
         reconcileTimer = setInterval(() => void configSync.reconcile(), RECONCILE_INTERVAL_MS);