@spzhongwin/skill-logger-plugin 1.0.17 → 1.0.19

package/dist/index.js

@@ -360,25 +360,25 @@ var require_utils = __commonJS({
       }
       mkdirSync(folder);
     };
-    Utils.prototype.writeFileTo = function(path12, content, overwrite, attr) {
+    Utils.prototype.writeFileTo = function(path16, content, overwrite, attr) {
       const self = this;
-      if (self.fs.existsSync(path12)) {
+      if (self.fs.existsSync(path16)) {
         if (!overwrite) return false;
-        var stat = self.fs.statSync(path12);
+        var stat = self.fs.statSync(path16);
         if (stat.isDirectory()) {
           return false;
         }
       }
-      var folder = pth.dirname(path12);
+      var folder = pth.dirname(path16);
       if (!self.fs.existsSync(folder)) {
         self.makeDir(folder);
       }
       var fd;
       try {
-        fd = self.fs.openSync(path12, "w", 438);
+        fd = self.fs.openSync(path16, "w", 438);
       } catch (e) {
-        self.fs.chmodSync(path12, 438);
-        fd = self.fs.openSync(path12, "w", 438);
+        self.fs.chmodSync(path16, 438);
+        fd = self.fs.openSync(path16, "w", 438);
       }
       if (fd) {
         try {
@@ -387,22 +387,22 @@ var require_utils = __commonJS({
           self.fs.closeSync(fd);
         }
       }
-      self.fs.chmodSync(path12, attr || 438);
+      self.fs.chmodSync(path16, attr || 438);
       return true;
     };
-    Utils.prototype.writeFileToAsync = function(path12, content, overwrite, attr, callback) {
+    Utils.prototype.writeFileToAsync = function(path16, content, overwrite, attr, callback) {
       if (typeof attr === "function") {
         callback = attr;
         attr = void 0;
       }
       const self = this;
-      self.fs.exists(path12, function(exist) {
+      self.fs.exists(path16, function(exist) {
         if (exist && !overwrite) return callback(false);
-        self.fs.stat(path12, function(err, stat) {
+        self.fs.stat(path16, function(err, stat) {
           if (exist && stat && stat.isDirectory()) {
             return callback(false);
           }
-          var folder = pth.dirname(path12);
+          var folder = pth.dirname(path16);
           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(path12, attr || 438, function() {
+                  self.fs.chmod(path16, attr || 438, function() {
                     callback(true);
                   });
                 });
               });
             };
-            self.fs.open(path12, "w", 438, function(err2, fd) {
+            self.fs.open(path16, "w", 438, function(err2, fd) {
               if (err2) {
-                self.fs.chmod(path12, 438, function() {
-                  self.fs.open(path12, "w", 438, function(retryErr, fd2) {
+                self.fs.chmod(path16, 438, function() {
+                  self.fs.open(path16, "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(path12) {
+    Utils.prototype.findFiles = function(path16) {
       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 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 : ""));
+          const path17 = pth.join(dir, file);
+          const stat = self.fs.statSync(path17);
+          if (!pattern || pattern.test(path17)) {
+            files.push(pth.normalize(path17) + (stat.isDirectory() ? self.sep : ""));
           }
           if (stat.isDirectory() && recursive) {
-            const realDir = self.fs.realpathSync(path13);
+            const realDir = self.fs.realpathSync(path17);
             if (!visited.has(realDir)) {
               visited.add(realDir);
-              files = files.concat(findSync(path13, pattern, recursive, visited));
+              files = files.concat(findSync(path17, pattern, recursive, visited));
             }
           }
         });
         return files;
       }
-      return findSync(path12, void 0, true, /* @__PURE__ */ new Set([self.fs.realpathSync(path12)]));
+      return findSync(path16, void 0, true, /* @__PURE__ */ new Set([self.fs.realpathSync(path16)]));
     };
     Utils.prototype.findFilesAsync = function(dir, cb) {
       const self = this;
@@ -539,14 +539,14 @@ var require_utils = __commonJS({
           return "UNSUPPORTED (" + method + ")";
       }
     };
-    Utils.canonical = function(path12) {
-      if (!path12) return "";
-      const safeSuffix = pth.posix.normalize("/" + path12.split("\\").join("/"));
+    Utils.canonical = function(path16) {
+      if (!path16) return "";
+      const safeSuffix = pth.posix.normalize("/" + path16.split("\\").join("/"));
       return pth.join(".", safeSuffix);
     };
-    Utils.zipnamefix = function(path12) {
-      if (!path12) return "";
-      const safeSuffix = pth.posix.normalize("/" + path12.split("\\").join("/"));
+    Utils.zipnamefix = function(path16) {
+      if (!path16) return "";
+      const safeSuffix = pth.posix.normalize("/" + path16.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 path12 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
-        if (path12 === prefix || path12.startsWith(prefix + pth.sep)) {
-          return path12;
+        var path16 = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
+        if (path16 === prefix || path16.startsWith(prefix + pth.sep)) {
+          return path16;
         }
       }
       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(path12, { fs: fs10 }) {
-      var _path = path12 || "", _obj = newAttr(), _stat = null;
+    module.exports = function(path16, { fs: fs13 }) {
+      var _path = path16 || "", _obj = newAttr(), _stat = null;
       function newAttr() {
         return {
           directory: false,
@@ -623,8 +623,8 @@ var require_fattr = __commonJS({
           atime: 0
         };
       }
-      if (_path && fs10.existsSync(_path)) {
-        _stat = fs10.statSync(_path);
+      if (_path && fs13.existsSync(_path)) {
+        _stat = fs13.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 fs9 from "node:fs";
-import path11 from "node:path";
+import fs12 from "node:fs";
+import path15 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import os4 from "node:os";
 
@@ -4639,9 +4639,151 @@ async function repairNestedExpertSkillLayouts(openclawRoot) {
 
 // src/ws-client.ts
 import WebSocket from "ws";
-import path9 from "path";
-import fs8 from "fs/promises";
+import path10 from "path";
+import fs9 from "fs/promises";
 import { DatabaseSync } from "node:sqlite";
+
+// src/free-skill-directory.ts
+import fs8 from "node:fs/promises";
+import path9 from "node:path";
+var FREE_SKILL_DIRECTORY_NAME = ".xg-platform";
+var SKILL_FILE_NAME = "SKILL.md";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithin(parent, candidate) {
+  const relative = path9.relative(parent, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path9.sep}`) && !path9.isAbsolute(relative);
+}
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function parseScalar(value) {
+  const trimmed = value.trim().replace(/\s+#.*$/, "").trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1).trim();
+  }
+  return trimmed;
+}
+function parseFrontmatter(content) {
+  const lines = content.replace(/^\uFEFF/, "").split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  const fields = {};
+  for (const line of lines.slice(1)) {
+    if (line.trim() === "---" || line.trim() === "...") break;
+    const match2 = /^\s*([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*?)\s*$/.exec(line);
+    if (match2) fields[match2[1]] = parseScalar(match2[2]);
+  }
+  return fields;
+}
+async function realPathIfRegularFile(filePath) {
+  try {
+    const resolved = await fs8.realpath(filePath);
+    const stats = await fs8.stat(resolved);
+    return stats.isFile() ? resolved : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readOptionalMetadata(skillPath, workspacePath) {
+  const candidate = path9.resolve(skillPath, ".meta.json");
+  if (!isWithin(skillPath, candidate) || !isWithin(workspacePath, candidate)) return {};
+  const metadataPath = await realPathIfRegularFile(candidate);
+  if (!metadataPath || !isWithin(skillPath, metadataPath) || !isWithin(workspacePath, metadataPath)) return {};
+  try {
+    const parsed = JSON.parse(await fs8.readFile(metadataPath, "utf8"));
+    if (!isRecord(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+async function scanSkill(directoryPath, workspacePath, entryName) {
+  const candidateSkillPath = path9.resolve(directoryPath, entryName);
+  if (!isWithin(directoryPath, candidateSkillPath) || !isWithin(workspacePath, candidateSkillPath)) return void 0;
+  const skillPath = await realPathIfRegularFile(candidateSkillPath);
+  if (skillPath) return void 0;
+  let resolvedSkillPath;
+  try {
+    resolvedSkillPath = await fs8.realpath(candidateSkillPath);
+    const stats = await fs8.stat(resolvedSkillPath);
+    if (!stats.isDirectory()) return void 0;
+  } catch {
+    return void 0;
+  }
+  if (!isWithin(directoryPath, resolvedSkillPath) || !isWithin(workspacePath, resolvedSkillPath)) return void 0;
+  const candidateSkillFilePath = path9.resolve(resolvedSkillPath, SKILL_FILE_NAME);
+  if (!isWithin(resolvedSkillPath, candidateSkillFilePath) || !isWithin(workspacePath, candidateSkillFilePath)) {
+    return void 0;
+  }
+  const skillFilePath = await realPathIfRegularFile(candidateSkillFilePath);
+  if (!skillFilePath || !isWithin(resolvedSkillPath, skillFilePath) || !isWithin(workspacePath, skillFilePath)) {
+    return void 0;
+  }
+  let skillFileContent;
+  try {
+    skillFileContent = await fs8.readFile(skillFilePath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const frontmatter = parseFrontmatter(skillFileContent);
+  const meta = await readOptionalMetadata(resolvedSkillPath, workspacePath);
+  const nestedMetadata = isRecord(meta.metadata) ? meta.metadata : {};
+  const getValue = (...values) => {
+    for (const value of values) {
+      const result = asNonEmptyString(value);
+      if (result) return result;
+    }
+    return void 0;
+  };
+  const code = entryName;
+  return {
+    code,
+    name: getValue(meta.name, nestedMetadata.name, frontmatter.name) ?? code,
+    description: getValue(meta.description, nestedMetadata.description, frontmatter.description) ?? "",
+    version: getValue(meta.version, nestedMetadata.version, frontmatter.version) ?? "",
+    directoryPath,
+    skillPath: resolvedSkillPath,
+    skillFilePath
+  };
+}
+async function scanFreeSkillDirectory(workspace) {
+  const resolvedWorkspace = path9.resolve(workspace);
+  let workspacePath;
+  try {
+    workspacePath = await fs8.realpath(resolvedWorkspace);
+    const stats = await fs8.stat(workspacePath);
+    if (!stats.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const candidateDirectoryPath = path9.resolve(workspacePath, FREE_SKILL_DIRECTORY_NAME);
+  if (!isWithin(workspacePath, candidateDirectoryPath)) return [];
+  let directoryPath;
+  try {
+    directoryPath = await fs8.realpath(candidateDirectoryPath);
+    const stats = await fs8.stat(directoryPath);
+    if (!stats.isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  if (!isWithin(workspacePath, directoryPath)) return [];
+  let entries;
+  try {
+    entries = await fs8.readdir(directoryPath, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+    if (!entry.isDirectory()) continue;
+    const skill = await scanSkill(directoryPath, workspacePath, entry.name);
+    if (skill) skills.push(skill);
+  }
+  return skills;
+}
+
+// src/ws-client.ts
 var HEARTBEAT_INTERVAL_MS = 3e4;
 var HEARTBEAT_ACK_TIMEOUT_MS = 75e3;
 var AGENT_SCAN_INTERVAL_MS = 3 * 60 * 1e3;
@@ -4694,10 +4836,10 @@ function resolveSkillInstallTarget(config, userId) {
   if (typeof workspace !== "string" || !workspace.trim()) {
     throw new Error(`\u672C\u5730 Agent ${localAgentId} \u672A\u914D\u7F6E workspace`);
   }
-  return { skillsDir: path9.join(workspace, "skills"), localAgentId };
+  return { skillsDir: path10.join(workspace, "skills"), localAgentId };
 }
 function normalizeAssistantUserId(userId) {
-  const safeUserId = path9.basename(userId);
+  const safeUserId = path10.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;
@@ -4706,23 +4848,29 @@ function normalizeAssistantUserId(userId) {
 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;
+  if (path10.basename(code) !== code) return void 0;
   return code;
 }
 function shouldSyncBuiltInTemplate(action, isBuiltIn) {
   return action === "UPDATE_SKILL" && isBuiltIn === true;
 }
+function resolveGatewaySkillTarget(home = openclawHome()) {
+  return path10.join(home, "skills");
+}
+function isGatewaySkillCommand(action, installScope) {
+  return installScope === "gateway" && ["INSTALL_SKILL", "UPDATE_SKILL", "UNINSTALL_SKILL"].includes(String(action || ""));
+}
 async function findInstalledExpertSkillsRoot(rootPath, pureId, code) {
-  const skillsRoot = path9.join(rootPath, `workspace-assistant-${pureId}`, ".user", "skills");
+  const skillsRoot = path10.join(rootPath, `workspace-assistant-${pureId}`, ".user", "skills");
   try {
-    const stat = await fs8.stat(path9.join(skillsRoot, code));
+    const stat = await fs9.stat(path10.join(skillsRoot, code));
     return stat.isDirectory() ? skillsRoot : void 0;
   } catch {
     return void 0;
   }
 }
 function defaultOpenclawSqlitePath() {
-  return path9.join(openclawHome(), "state", "openclaw.sqlite");
+  return path10.join(openclawHome(), "state", "openclaw.sqlite");
 }
 function readCronJobsByAgentId(agentId, sqlitePath = defaultOpenclawSqlitePath(), onError) {
   let db;
@@ -4736,6 +4884,49 @@ function readCronJobsByAgentId(agentId, sqlitePath = defaultOpenclawSqlitePath()
     db?.close();
   }
 }
+function isWithinPath(parent, candidate) {
+  const relative = path10.relative(parent, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path10.sep}`) && !path10.isAbsolute(relative);
+}
+function relativeWorkspacePath(workspace, target) {
+  const relative = path10.relative(workspace, target);
+  return isWithinPath(workspace, target) ? relative : "";
+}
+async function resolveRealWorkspace(workspace) {
+  const resolved = path10.resolve(workspace);
+  try {
+    return await fs9.realpath(resolved);
+  } catch {
+    return resolved;
+  }
+}
+async function resolveFreeSkillDirectoryPath(workspace) {
+  const workspacePath = await resolveRealWorkspace(workspace);
+  const candidate = path10.resolve(workspacePath, ".xg-platform");
+  try {
+    const directoryPath = await fs9.realpath(candidate);
+    const stat = await fs9.stat(directoryPath);
+    return stat.isDirectory() && isWithinPath(workspacePath, directoryPath) ? directoryPath : "";
+  } catch {
+    return "";
+  }
+}
+function buildFreeSkillDirectoryResponse(gatewayId, agentId, workspacePath, directoryPath, skills) {
+  return {
+    gatewayId,
+    agentId,
+    directoryPath,
+    skills: skills.map((skill) => ({
+      code: skill.code,
+      name: skill.name,
+      description: skill.description,
+      version: skill.version,
+      workspaceRelativePath: relativeWorkspacePath(workspacePath, skill.skillPath),
+      skillFilePath: relativeWorkspacePath(workspacePath, skill.skillFilePath),
+      hostSkillFilePath: skill.skillFilePath
+    }))
+  };
+}
 var GatewayWsClient = class {
   ws = null;
   options;
@@ -4762,10 +4953,10 @@ var GatewayWsClient = class {
         }
       }
       logLine += "\n";
-      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(() => {
+      const logsDir = path10.join(openclawHome(), "logs");
+      fs9.mkdir(logsDir, { recursive: true }).then(() => {
+        const logPath = path10.join(logsDir, "skill-logger.err");
+        fs9.appendFile(logPath, logLine).catch(() => {
         });
       }).catch(() => {
       });
@@ -4780,16 +4971,25 @@ var GatewayWsClient = class {
       });
     };
   }
-  /** 普通 Skill 的所有读写操作共用这一个配置驱动的寻址入口。 */
-  async resolveRegularSkillTarget(userId) {
-    const configPath = path9.join(openclawHome(), "openclaw.json");
-    let config;
+  async readOpenclawConfig() {
+    const configPath = path10.join(openclawHome(), "openclaw.json");
     try {
-      config = JSON.parse(await fs8.readFile(configPath, "utf-8"));
+      return JSON.parse(await fs9.readFile(configPath, "utf-8"));
     } catch (err) {
       throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 openclaw.json: ${err?.message || String(err)}`);
     }
-    return resolveSkillInstallTarget(config, userId).skillsDir;
+  }
+  async resolveRegularSkillContext(userId) {
+    const target = resolveSkillInstallTarget(await this.readOpenclawConfig(), userId);
+    return { ...target, workspace: path10.dirname(target.skillsDir) };
+  }
+  /** 普通 Skill 的所有读写操作共用这一个配置驱动的寻址入口。 */
+  async resolveRegularSkillTarget(userId) {
+    return (await this.resolveRegularSkillContext(userId)).skillsDir;
+  }
+  async resolveFreeSkillRequestContext(userId) {
+    const target = await this.resolveRegularSkillContext(userId);
+    return { workspace: target.workspace, agentId: target.localAgentId };
   }
   constructor(options) {
     this.options = options;
@@ -4890,10 +5090,10 @@ var GatewayWsClient = class {
   async scanAndReportAgents(isInitialReport) {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
     try {
-      const configPath = path9.join(openclawHome(), "openclaw.json");
+      const configPath = path10.join(openclawHome(), "openclaw.json");
       let rawConfig;
       try {
-        rawConfig = await fs8.readFile(configPath, "utf-8");
+        rawConfig = await fs9.readFile(configPath, "utf-8");
       } catch (e) {
         this.appendLogToFile("WARN", "AgentScan", "OpenClaw config is not readable; skipping this scan cycle", e);
         return;
@@ -5013,7 +5213,8 @@ var GatewayWsClient = class {
       gatewayId: this.options.gatewayId,
       agentIds: Array.from(this.currentAgentIds),
       clientTime: Date.now(),
-      supportsBatch: true
+      supportsBatch: true,
+      supportsGatewaySkillScope: true
     }, "Heartbeat");
   }
   sendClientHeartbeat() {
@@ -5042,7 +5243,7 @@ var GatewayWsClient = class {
    * 核心指令分发中心：完全跳过沙盒，基于 userId 直接进行底层物理文件操作
    */
   async handleMessage(msg) {
-    const { action, userId, code, url, force, version, replyId, isBuiltIn } = msg;
+    const { action, userId, code, url, force, version, replyId, isBuiltIn, installScope } = msg;
     this.appendLogToFile("INFO", "Command", `Received WS message`, {
       action,
       userId,
@@ -5050,6 +5251,7 @@ var GatewayWsClient = class {
       version,
       replyId,
       isBuiltIn,
+      installScope,
       hasDirectUrl: Boolean(url)
     });
     if (!action) {
@@ -5075,6 +5277,14 @@ var GatewayWsClient = class {
     }
     if (!userId) {
       this.appendLogToFile("WARN", "Command", `Message dropped: missing userId`, msg);
+      if (action === "LIST_FREE_SKILLS") {
+        this.reply(replyId, {
+          success: false,
+          error: "INVALID_REQUEST",
+          message: "Missing userId parameter",
+          action
+        });
+      }
       return;
     }
     const safeCode = normalizeCommandCode(code);
@@ -5082,15 +5292,16 @@ var GatewayWsClient = class {
       this.reply(replyId, { success: false, message: `Invalid code: ${String(code)}`, action });
       return;
     }
-    const pureId = normalizeAssistantUserId(userId);
-    if (!pureId) {
+    const gatewaySkillCommand = isGatewaySkillCommand(action, installScope);
+    const pureId = gatewaySkillCommand ? void 0 : normalizeAssistantUserId(userId);
+    if (!gatewaySkillCommand && !pureId) {
       this.reply(replyId, { success: false, message: `Invalid userId: ${userId}`, action });
       return;
     }
     try {
       if (action === "INSTALL_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
-        const targetDir = await this.resolveRegularSkillTarget(userId);
+        const targetDir = gatewaySkillCommand ? resolveGatewaySkillTarget() : 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({
@@ -5101,109 +5312,132 @@ var GatewayWsClient = class {
           targetDir,
           trace: this.createInstallTrace({ action, replyId, userId, code: safeCode })
         });
-        this.reply(replyId, { success: result.success, message: result.message, action });
+        this.reply(replyId, {
+          success: result.success,
+          message: result.message,
+          action,
+          data: { code: safeCode, version, installScope: gatewaySkillCommand ? "gateway" : "agent" }
+        });
       } else if (action === "UNINSTALL_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
-        const targetDir = await this.resolveRegularSkillTarget(userId);
+        const targetDir = gatewaySkillCommand ? resolveGatewaySkillTarget() : 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 = path9.join(targetDir, safeCode);
-        await fs8.rm(skillPath, { recursive: true, force: true });
-        this.reply(replyId, { success: true, message: `Skill ${safeCode} removed`, action });
+        const skillPath = path10.join(targetDir, safeCode);
+        await fs9.rm(skillPath, { recursive: true, force: true });
+        this.reply(replyId, {
+          success: true,
+          message: `Skill ${safeCode} removed`,
+          action,
+          data: { code: safeCode, installScope: gatewaySkillCommand ? "gateway" : "agent", removed: true }
+        });
+      } else if (action === "LIST_FREE_SKILLS") {
+        const context = await this.resolveFreeSkillRequestContext(userId);
+        const workspacePath = await resolveRealWorkspace(context.workspace);
+        const scannedSkills = await scanFreeSkillDirectory(context.workspace);
+        const directoryPath = scannedSkills[0]?.directoryPath || await resolveFreeSkillDirectoryPath(context.workspace);
+        const data = buildFreeSkillDirectoryResponse(
+          this.options.gatewayId,
+          context.agentId,
+          workspacePath,
+          directoryPath,
+          scannedSkills
+        );
+        this.reply(replyId, { success: true, data, action });
       } else if (action === "LIST_SKILLS") {
-        const targetDir = await this.resolveRegularSkillTarget(userId);
-        let list = [];
-        let targetDirExists = false;
-        try {
-          const targetStat = await fs8.stat(targetDir);
-          targetDirExists = targetStat.isDirectory();
-        } catch (err) {
-          if (err?.code !== "ENOENT") throw err;
-        }
-        if (!targetDirExists) {
-          throw new Error(`Target skills directory does not exist: ${targetDir}`);
-        }
-        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 = path9.join(targetDir, e.name);
-          const skillMdPath = path9.join(skillDir, "SKILL.md");
+        const regularTargetDir = await this.resolveRegularSkillTarget(userId);
+        const skillsByCode = /* @__PURE__ */ new Map();
+        const sources = [
+          { dir: regularTargetDir, gatewayBuiltIn: false },
+          { dir: resolveGatewaySkillTarget(), gatewayBuiltIn: true }
+        ];
+        for (const source of sources) {
+          let entries;
           try {
-            const stat = await fs8.stat(skillMdPath);
-            if (!stat.isFile()) continue;
+            entries = await fs9.readdir(source.dir, { withFileTypes: true });
           } catch (err) {
-            continue;
+            if (err?.code === "ENOENT") continue;
+            throw err;
           }
-          const metaPath = path9.join(skillDir, ".meta.json");
-          let isPlatform = false;
-          let isBuiltIn2 = e.isSymbolicLink();
-          let metaData = null;
-          let name = e.name;
-          let description = "";
-          let skillVersion = "";
-          try {
-            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;
-            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();
+          const dirs = entries.filter((e) => (e.isDirectory() || e.isSymbolicLink()) && !e.name.startsWith("."));
+          for (const e of dirs) {
+            const skillDir = path10.join(source.dir, e.name);
+            const skillMdPath = path10.join(skillDir, "SKILL.md");
+            try {
+              const stat = await fs9.stat(skillMdPath);
+              if (!stat.isFile()) continue;
+            } catch {
+              continue;
             }
-          } catch (err) {
-          }
-          try {
-            const metaContent = await fs8.readFile(metaPath, "utf8");
-            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") isBuiltIn2 = true;
-              metaData = parsed;
+            const metaPath = path10.join(skillDir, ".meta.json");
+            let isPlatform = source.gatewayBuiltIn;
+            let isBuiltIn2 = source.gatewayBuiltIn || e.isSymbolicLink();
+            let metaData = null;
+            let name = e.name;
+            let description = "";
+            let skillVersion = "";
+            try {
+              const mdContent = await fs9.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 descMatch = /(^|\n)description:\s*(?:>\s*\n\s*)?(.*?)(?=\n[a-z]+:|\n---|$)/is.exec(fm);
+              if (descMatch?.[2]) description = descMatch[2].replace(/\n\s+/g, " ").trim();
+            } catch {
+            }
+            try {
+              const parsed = JSON.parse(await fs9.readFile(metaPath, "utf8"));
+              if (parsed) {
+                if (parsed.ownerId === "CMS" || parsed.ownerId === "CMS_COMPAT") isPlatform = true;
+                if (parsed.isBuiltIn === true || parsed.ownerId === "built-in") isBuiltIn2 = true;
+                metaData = parsed;
+              }
+            } catch {
+            }
+            const resolvedVersion = await readSkillVersion(skillDir);
+            if (resolvedVersion) skillVersion = resolvedVersion;
+            if (isPlatform) {
+              skillsByCode.set(e.name, {
+                code: e.name,
+                isPlatform: true,
+                isBuiltIn: isBuiltIn2,
+                version: skillVersion,
+                name,
+                description,
+                publishedAt: metaData?.publishedAt
+              });
+            } else {
+              skillsByCode.set(e.name, {
+                code: e.name,
+                isPlatform: false,
+                isBuiltIn: isBuiltIn2,
+                version: skillVersion,
+                name,
+                description
+              });
             }
-          } catch (err) {
-          }
-          const resolvedVersion = await readSkillVersion(skillDir);
-          if (resolvedVersion) skillVersion = resolvedVersion;
-          if (isPlatform) {
-            list.push({
-              code: e.name,
-              isPlatform: true,
-              isBuiltIn: isBuiltIn2,
-              version: skillVersion,
-              name,
-              description,
-              publishedAt: metaData?.publishedAt
-            });
-          } else {
-            list.push({
-              code: e.name,
-              isPlatform: false,
-              isBuiltIn: isBuiltIn2,
-              version: skillVersion,
-              name,
-              description
-            });
           }
         }
-        this.reply(replyId, { success: true, data: list, action });
+        this.reply(replyId, { success: true, data: [...skillsByCode.values()], action });
       } else if (action === "UPDATE_SKILL") {
         if (!safeCode) throw new Error("Missing code parameter");
         const delayMs = Math.random() * 5e3;
-        const syncBuiltInTemplate = shouldSyncBuiltInTemplate(action, isBuiltIn);
+        const syncBuiltInTemplate = !gatewaySkillCommand && 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,
           isBuiltIn,
+          installScope,
           syncBuiltInTemplate,
           delayMs: Math.round(delayMs)
         });
         setTimeout(async () => {
           try {
-            const targetDir = await this.resolveRegularSkillTarget(userId);
-            const additionalTargetDirs = syncBuiltInTemplate ? [path9.join(openclawHome(), "workspace-xgjk-assistant-template", "skills")] : [];
-            const userSkillRoot = await findInstalledExpertSkillsRoot(openclawHome(), pureId, safeCode);
+            const targetDir = gatewaySkillCommand ? resolveGatewaySkillTarget() : await this.resolveRegularSkillTarget(userId);
+            const additionalTargetDirs = syncBuiltInTemplate ? [path10.join(openclawHome(), "workspace-xgjk-assistant-template", "skills")] : [];
+            const userSkillRoot = pureId ? await findInstalledExpertSkillsRoot(openclawHome(), pureId, safeCode) : void 0;
             if (userSkillRoot) additionalTargetDirs.push(userSkillRoot);
             const result = await this.options.updater.manualInstall({
               code: safeCode,
@@ -5230,7 +5464,12 @@ var GatewayWsClient = class {
               syncBuiltInTemplate
             });
             if (replyId) {
-              this.reply(replyId, { success: result.success, message: result.message, action });
+              this.reply(replyId, {
+                success: result.success,
+                message: result.message,
+                action,
+                data: { code: safeCode, version, installScope: gatewaySkillCommand ? "gateway" : "agent" }
+              });
             }
           } catch (e) {
             this.appendLogToFile("ERROR", "Command", `UPDATE_SKILL threw`, {
@@ -5248,12 +5487,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 = path9.join(openclawHome(), `workspace-assistant-${pureId}`, ".user");
-        const expertTarget = path9.join(userSkillRoot, "experts", safeCode);
+        const userSkillRoot = path10.join(openclawHome(), `workspace-assistant-${pureId}`, ".user");
+        const expertTarget = path10.join(userSkillRoot, "experts", safeCode);
         let skipInstall = false;
-        const metaPath = path9.join(expertTarget, ".meta.json");
+        const metaPath = path10.join(expertTarget, ".meta.json");
         try {
-          const raw = await fs8.readFile(metaPath, "utf-8");
+          const raw = await fs9.readFile(metaPath, "utf-8");
           const existing = JSON.parse(raw);
           if (existing.version && existing.version === (version2 || "1.0.0")) {
             skipInstall = true;
@@ -5261,16 +5500,16 @@ var GatewayWsClient = class {
         } catch {
         }
         if (!skipInstall) {
-          await fs8.mkdir(path9.dirname(expertTarget), { recursive: true });
+          await fs9.mkdir(path10.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 fs8.writeFile(metaPath, JSON.stringify(meta, null, 2));
-        const skillTargetRoot = path9.join(userSkillRoot, "skills");
-        await fs8.mkdir(skillTargetRoot, { recursive: true });
+        await fs9.writeFile(metaPath, JSON.stringify(meta, null, 2));
+        const skillTargetRoot = path10.join(userSkillRoot, "skills");
+        await fs9.mkdir(skillTargetRoot, { recursive: true });
         const skillResults = [];
         if (Array.isArray(skills)) {
           for (const sk of skills) {
@@ -5307,23 +5546,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 = path9.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts", safeCode);
-        await fs8.rm(expertPath, { recursive: true, force: true });
+        const expertPath = path10.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts", safeCode);
+        await fs9.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 = path9.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts");
+        const expertsDir = path10.join(openclawHome(), `workspace-assistant-${pureId}`, ".user", "experts");
         const list = [];
         try {
-          const stat = await fs8.stat(expertsDir);
+          const stat = await fs9.stat(expertsDir);
           if (stat.isDirectory()) {
-            const entries = await fs8.readdir(expertsDir, { withFileTypes: true });
+            const entries = await fs9.readdir(expertsDir, { withFileTypes: true });
             for (const e of entries) {
               if (!e.isDirectory()) continue;
-              const metaPath = path9.join(expertsDir, e.name, ".meta.json");
+              const metaPath = path10.join(expertsDir, e.name, ".meta.json");
               try {
-                const raw = await fs8.readFile(metaPath, "utf-8");
+                const raw = await fs9.readFile(metaPath, "utf-8");
                 const meta = JSON.parse(raw);
                 list.push({
                   code: meta.code || e.name,
@@ -5342,7 +5581,17 @@ var GatewayWsClient = class {
       } else {
         console.warn(`[skill-logger-plugin][WS] Unknown action: ${action}`);
         this.appendLogToFile("WARN", "Command", `Unknown action: ${action}`);
-        this.reply(replyId, { success: false, message: `Unknown action: ${action}`, action });
+        if (action === "LIST_FREE_SKILLS") {
+          this.reply(replyId, {
+            success: false,
+            unsupported: true,
+            error: "UNSUPPORTED_ACTION",
+            message: "LIST_FREE_SKILLS unsupported by this plugin",
+            action
+          });
+        } else {
+          this.reply(replyId, { success: false, message: `Unknown action: ${action}`, action });
+        }
       }
     } catch (err) {
       this.appendLogToFile("ERROR", "Command", `Error executing action ${action}`, err);
@@ -5377,7 +5626,7 @@ var GatewayWsClient = class {
 };
 
 // src/hooks.ts
-import path10 from "node:path";
+import path11 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 var PENDING_TTL_MS = 30 * 60 * 1e3;
 var PENDING_MAX = 5e3;
@@ -5386,7 +5635,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 path10.basename(filePath) === "SKILL.md";
+  return path11.basename(filePath) === "SKILL.md";
 }
 function extractAppKey(event, ctx) {
   try {
@@ -5566,8 +5815,8 @@ var Hooks = class {
       if (toolName === "read") {
         const filePath = params.path ?? params.file_path ?? "";
         if (!isSkillMdReadPath(filePath)) return;
-        const rootDir = path10.dirname(filePath);
-        const skillName = this.configSync.resolveSkillName(rootDir) || path10.basename(rootDir);
+        const rootDir = path11.dirname(filePath);
+        const skillName = this.configSync.resolveSkillName(rootDir) || path11.basename(rootDir);
         if (!skillName) return;
         this.debug(`Intercepted 'read' for SKILL.md. Attributed to skill: ${skillName}`);
         this.recordTrigger(skillName, "inline", "read", ctx, appKey);
@@ -5749,6 +5998,637 @@ var Hooks = class {
   }
 };
 
+// src/free-skill-tool.ts
+import path14 from "node:path";
+
+// src/free-skill-writer.ts
+import crypto from "node:crypto";
+import fs11 from "node:fs/promises";
+import path13 from "node:path";
+
+// src/free-skill-workspace.ts
+import fs10 from "node:fs/promises";
+import path12 from "node:path";
+var FREE_SKILL_DIRECTORY_NAME2 = ".xg-platform";
+var FreeSkillWorkspaceError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "FreeSkillWorkspaceError";
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function isWithin2(parent, candidate) {
+  const relative = path12.relative(parent, candidate);
+  return relative === "" || !relative.startsWith(`..${path12.sep}`) && relative !== ".." && !path12.isAbsolute(relative);
+}
+function nestedRecord(value, key) {
+  if (!isRecord2(value)) return void 0;
+  const nested = value[key];
+  return isRecord2(nested) ? nested : void 0;
+}
+function firstWorkspaceValue(context) {
+  if (!isRecord2(context)) return void 0;
+  const wrapped = nestedRecord(context, "ctx");
+  const nestedContext = nestedRecord(context, "context");
+  const candidates = [
+    context.workspaceDir,
+    context.workspace,
+    wrapped?.workspaceDir,
+    wrapped?.workspace,
+    nestedContext?.workspaceDir,
+    nestedContext?.workspace
+  ];
+  return candidates.map(nonEmptyString).find((value) => Boolean(value));
+}
+function firstAgentIdValue(context) {
+  if (!isRecord2(context)) return void 0;
+  const wrapped = nestedRecord(context, "ctx");
+  const nestedContext = nestedRecord(context, "context");
+  const agent = isRecord2(context.agent) ? context.agent.id : void 0;
+  const wrappedAgent = isRecord2(wrapped?.agent) ? wrapped?.agent.id : void 0;
+  const nestedContextAgent = isRecord2(nestedContext?.agent) ? nestedContext?.agent.id : void 0;
+  const candidates = [
+    context.agentId,
+    agent,
+    wrapped?.agentId,
+    wrappedAgent,
+    nestedContext?.agentId,
+    nestedContextAgent
+  ];
+  return candidates.map(nonEmptyString).find((value) => Boolean(value));
+}
+async function resolveWorkspacePath(workspaceInput) {
+  let workspacePath;
+  try {
+    workspacePath = await fs10.realpath(path12.resolve(workspaceInput));
+  } catch {
+    throw new FreeSkillWorkspaceError(
+      "WORKSPACE_MISSING",
+      `Agent workspace \u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BBF\u95EE: ${workspaceInput}`
+    );
+  }
+  try {
+    const stat = await fs10.stat(workspacePath);
+    if (!stat.isDirectory()) {
+      throw new FreeSkillWorkspaceError(
+        "WORKSPACE_NOT_DIRECTORY",
+        `Agent workspace \u4E0D\u662F\u76EE\u5F55: ${workspaceInput}`
+      );
+    }
+  } catch (error) {
+    if (error instanceof FreeSkillWorkspaceError) throw error;
+    throw new FreeSkillWorkspaceError(
+      "WORKSPACE_MISSING",
+      `Agent workspace \u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BBF\u95EE: ${workspaceInput}`
+    );
+  }
+  return workspacePath;
+}
+async function resolvePlatformDirectory(workspacePath) {
+  const candidate = path12.resolve(workspacePath, FREE_SKILL_DIRECTORY_NAME2);
+  if (!isWithin2(workspacePath, candidate)) {
+    throw new FreeSkillWorkspaceError(
+      "PLATFORM_DIRECTORY_ESCAPE",
+      "`.xg-platform` \u4E0D\u5728 Agent workspace \u5185"
+    );
+  }
+  let entry;
+  try {
+    entry = await fs10.lstat(candidate);
+  } catch (error) {
+    if (error?.code === "ENOENT") return candidate;
+    throw new FreeSkillWorkspaceError(
+      "PLATFORM_DIRECTORY_BROKEN_LINK",
+      "\u65E0\u6CD5\u68C0\u67E5 Agent workspace \u4E0B\u7684 `.xg-platform`"
+    );
+  }
+  let resolved = candidate;
+  if (entry.isSymbolicLink()) {
+    try {
+      resolved = await fs10.realpath(candidate);
+    } catch {
+      throw new FreeSkillWorkspaceError(
+        "PLATFORM_DIRECTORY_BROKEN_LINK",
+        "`.xg-platform` \u662F\u5931\u6548\u7B26\u53F7\u94FE\u63A5"
+      );
+    }
+    if (!isWithin2(workspacePath, resolved)) {
+      throw new FreeSkillWorkspaceError(
+        "PLATFORM_DIRECTORY_ESCAPE",
+        "`.xg-platform` \u7B26\u53F7\u94FE\u63A5\u8D8A\u51FA Agent workspace"
+      );
+    }
+  }
+  try {
+    const stat = await fs10.stat(resolved);
+    if (!stat.isDirectory()) {
+      throw new FreeSkillWorkspaceError(
+        "PLATFORM_DIRECTORY_NOT_DIRECTORY",
+        "Agent workspace \u4E0B\u7684 `.xg-platform` \u4E0D\u662F\u76EE\u5F55"
+      );
+    }
+  } catch (error) {
+    if (error instanceof FreeSkillWorkspaceError) throw error;
+    throw new FreeSkillWorkspaceError(
+      "PLATFORM_DIRECTORY_BROKEN_LINK",
+      "\u65E0\u6CD5\u8BBF\u95EE Agent workspace \u4E0B\u7684 `.xg-platform`"
+    );
+  }
+  return resolved;
+}
+async function resolveFreeSkillWorkspace(context, fallbackWorkspace) {
+  const workspaceInput = firstWorkspaceValue(context) ?? nonEmptyString(fallbackWorkspace);
+  if (!workspaceInput) {
+    throw new FreeSkillWorkspaceError(
+      "WORKSPACE_MISSING",
+      "\u672A\u63D0\u4F9B\u5F53\u524D Agent workspace"
+    );
+  }
+  const workspacePath = await resolveWorkspacePath(workspaceInput);
+  const directoryPath = await resolvePlatformDirectory(workspacePath);
+  return {
+    agentId: firstAgentIdValue(context),
+    workspacePath,
+    directoryPath,
+    workspaceRelativePath: FREE_SKILL_DIRECTORY_NAME2
+  };
+}
+
+// src/free-skill-writer.ts
+var FREE_SKILL_DIRECTORY_NAME3 = ".xg-platform";
+var SKILL_FILE_NAME2 = "SKILL.md";
+var FreeSkillWriterError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "FreeSkillWriterError";
+  }
+};
+var defaultFileSystem = {
+  lstat: fs11.lstat,
+  realpath: fs11.realpath,
+  stat: fs11.stat,
+  mkdir: fs11.mkdir,
+  writeFile: fs11.writeFile,
+  rename: fs11.rename,
+  rm: fs11.rm
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithin3(parent, candidate) {
+  const relative = path13.relative(parent, candidate);
+  return relative === "" || !relative.startsWith(`..${path13.sep}`) && relative !== ".." && !path13.isAbsolute(relative);
+}
+function asErrnoCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function asMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function fail(code, message) {
+  throw new FreeSkillWriterError(code, message);
+}
+function stripYamlComment(value) {
+  let quote;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"' && character === "\\") {
+      index += 1;
+      continue;
+    }
+    if ((character === "'" || character === '"') && (!quote || quote === character)) {
+      if (quote === "'" && character === "'" && value[index + 1] === "'") {
+        index += 1;
+        continue;
+      }
+      quote = quote ? void 0 : character;
+      continue;
+    }
+    if (!quote && character === "#" && (index === 0 || /\s/.test(value[index - 1]))) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value.trim();
+}
+function parseQuotedScalar(rawValue) {
+  if (rawValue.startsWith('"')) {
+    if (!rawValue.endsWith('"')) return void 0;
+    try {
+      const parsed = JSON.parse(rawValue);
+      return typeof parsed === "string" ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  if (rawValue.startsWith("'")) {
+    if (!rawValue.endsWith("'")) return void 0;
+    const inner = rawValue.slice(1, -1);
+    let value = "";
+    for (let index = 0; index < inner.length; index += 1) {
+      if (inner[index] === "'" && inner[index + 1] === "'") {
+        value += "'";
+        index += 1;
+      } else if (inner[index] === "'") {
+        return void 0;
+      } else {
+        value += inner[index];
+      }
+    }
+    return value;
+  }
+  return void 0;
+}
+function hasBalancedCollection(value) {
+  const opening = value[0];
+  const closing = opening === "[" ? "]" : "}";
+  if (opening !== "[" && opening !== "{" || !value.endsWith(closing)) return false;
+  let depth = 0;
+  let quote;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"' && character === "\\") {
+      index += 1;
+      continue;
+    }
+    if ((character === "'" || character === '"') && (!quote || quote === character)) {
+      if (quote === "'" && character === "'" && value[index + 1] === "'") {
+        index += 1;
+        continue;
+      }
+      quote = quote ? void 0 : character;
+      continue;
+    }
+    if (quote) continue;
+    if (character === opening) depth += 1;
+    if (character === closing) depth -= 1;
+    if (depth < 0) return false;
+  }
+  return depth === 0 && !quote;
+}
+function parseInlineValue(rawValue) {
+  const value = stripYamlComment(rawValue);
+  if (value.startsWith('"') || value.startsWith("'")) {
+    const parsed = parseQuotedScalar(value);
+    if (parsed === void 0) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter \u4E2D\u5B58\u5728\u672A\u95ED\u5408\u6216\u65E0\u6548\u5B57\u7B26\u4E32");
+    return { kind: "scalar", value: parsed };
+  }
+  if (value.startsWith("[") || value.startsWith("{")) {
+    if (!hasBalancedCollection(value)) {
+      fail("INVALID_FRONTMATTER", "SKILL.md frontmatter \u4E2D\u5B58\u5728\u672A\u95ED\u5408\u96C6\u5408\u503C");
+    }
+    return { kind: "other" };
+  }
+  return { kind: "scalar", value };
+}
+function parseBlockValue(lines, startIndex, header) {
+  const headerMatch = /^([|>])(?:[+-]|[1-9])?$/.exec(header);
+  if (!headerMatch) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter \u4E2D\u5B58\u5728\u65E0\u6548\u5757\u6807\u91CF");
+  const blockLines = [];
+  let index = startIndex;
+  let contentIndent;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.trim() !== "" && !/^\s+/.test(line)) break;
+    if (line.trim() === "") {
+      blockLines.push("");
+      index += 1;
+      continue;
+    }
+    const indent = line.match(/^\s*/)?.[0].length ?? 0;
+    contentIndent ??= indent;
+    if (indent < contentIndent) break;
+    blockLines.push(line.slice(contentIndent));
+    index += 1;
+  }
+  if (headerMatch[1] === ">") {
+    const folded = [];
+    for (const line of blockLines) {
+      if (line === "") {
+        folded.push("\n");
+      } else if (folded.length > 0 && folded[folded.length - 1] !== "\n") {
+        folded.push(" ", line);
+      } else {
+        folded.push(line);
+      }
+    }
+    return { value: folded.join(""), nextIndex: index };
+  }
+  return { value: blockLines.join("\n"), nextIndex: index };
+}
+function parseFrontmatter2(content) {
+  const normalized = content.replace(/^\uFEFF/, "");
+  const lines = normalized.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    fail("INVALID_FRONTMATTER", "SKILL.md \u5FC5\u987B\u4EE5 YAML frontmatter \u5F00\u59CB");
+  }
+  const fields = /* @__PURE__ */ new Map();
+  let closingIndex = -1;
+  let index = 1;
+  while (index < lines.length) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (trimmed === "---" || trimmed === "...") {
+      closingIndex = index;
+      break;
+    }
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      index += 1;
+      continue;
+    }
+    if (/^\s/.test(line) || line.includes("	")) {
+      fail("INVALID_FRONTMATTER", "SKILL.md frontmatter \u4E2D\u5B58\u5728\u65E0\u6548\u7F29\u8FDB");
+    }
+    const match2 = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*?)\s*$/.exec(line);
+    if (!match2) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter \u4E2D\u5B58\u5728\u65E0\u6548\u5B57\u6BB5");
+    const [, key, rawValue] = match2;
+    if (fields.has(key)) fail("INVALID_FRONTMATTER", `SKILL.md frontmatter \u5B57\u6BB5\u91CD\u590D: ${key}`);
+    const value = stripYamlComment(rawValue);
+    if (value === "|" || value === ">" || /^[|>][+-]$/.test(value)) {
+      const block = parseBlockValue(lines, index + 1, value);
+      fields.set(key, { kind: "scalar", value: block.value });
+      index = block.nextIndex;
+      continue;
+    }
+    fields.set(key, parseInlineValue(rawValue));
+    index += 1;
+  }
+  if (closingIndex < 0) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter \u7F3A\u5C11\u7ED3\u675F\u6807\u8BB0");
+  const name = fields.get("name");
+  if (!name || name.kind !== "scalar" || !name.value.trim()) {
+    fail("MISSING_NAME", "SKILL.md frontmatter \u5FC5\u987B\u5305\u542B\u975E\u7A7A name");
+  }
+  const description = fields.get("description");
+  if (!description || description.kind !== "scalar" || !description.value.trim()) {
+    fail("MISSING_DESCRIPTION", "SKILL.md frontmatter \u5FC5\u987B\u5305\u542B\u975E\u7A7A description");
+  }
+  const body = lines.slice(closingIndex + 1).join("\n");
+  if (!body.trim()) fail("EMPTY_BODY", "SKILL.md \u6B63\u6587\u4E0D\u80FD\u4E3A\u7A7A");
+  return { name: name.value.trim(), description: description.value.trim(), body };
+}
+function validateFreeSkillContent(content) {
+  if (typeof content !== "string") fail("INVALID_CONTENT", "SKILL.md \u5185\u5BB9\u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  return parseFrontmatter2(content);
+}
+function validateSkillName(value) {
+  if (typeof value !== "string" || value.length === 0 || value !== value.trim()) {
+    fail("INVALID_SKILL_NAME", "Skill \u540D\u79F0\u5FC5\u987B\u662F\u975E\u7A7A\u7684\u5355\u7EA7\u76EE\u5F55\u540D");
+  }
+  if (value === "." || value === ".." || value.startsWith(".") || value.endsWith(".") || value.endsWith(" ") || path13.basename(value) !== value || path13.win32.basename(value) !== value || path13.isAbsolute(value) || /[\\/\0<>:"|?*\u0000-\u001f\u007f]/u.test(value)) {
+    fail("INVALID_SKILL_NAME", `\u975E\u6CD5\u7684 Skill \u540D\u79F0: ${value}`);
+  }
+  return value;
+}
+function serializeMetadata(value) {
+  if (value === void 0) return void 0;
+  if (!isRecord3(value)) fail("INVALID_METADATA", ".meta.json metadata \u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    if (serialized === void 0) fail("INVALID_METADATA", ".meta.json metadata \u65E0\u6CD5\u5E8F\u5217\u5316");
+    return `${serialized}
+`;
+  } catch (error) {
+    fail("INVALID_METADATA", `.meta.json metadata \u65E0\u6CD5\u5E8F\u5217\u5316: ${asMessage(error)}`);
+  }
+}
+function isResolvedWorkspace(value) {
+  if (!isRecord3(value)) return false;
+  return typeof value.workspacePath === "string" && typeof value.directoryPath === "string" && value.workspaceRelativePath === FREE_SKILL_DIRECTORY_NAME3;
+}
+async function ensurePlatformDirectory(workspace, io) {
+  if (!path13.isAbsolute(workspace.workspacePath) || !path13.isAbsolute(workspace.directoryPath)) {
+    fail("TARGET_ESCAPE", "Skill workspace \u8DEF\u5F84\u5FC5\u987B\u662F\u89E3\u6790\u5668\u8FD4\u56DE\u7684\u7EDD\u5BF9\u8DEF\u5F84");
+  }
+  let workspacePath;
+  try {
+    workspacePath = await io.realpath(path13.resolve(workspace.workspacePath));
+    const workspaceStat = await io.stat(workspacePath);
+    if (!workspaceStat.isDirectory()) fail("WORKSPACE_NOT_DIRECTORY", "Agent workspace \u4E0D\u662F\u76EE\u5F55");
+  } catch (error) {
+    if (error instanceof FreeSkillWriterError) throw error;
+    fail("WORKSPACE_MISSING", `Agent workspace \u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BBF\u95EE: ${asMessage(error)}`);
+  }
+  const directoryPath = path13.resolve(workspacePath, FREE_SKILL_DIRECTORY_NAME3);
+  if (!isWithin3(workspacePath, directoryPath) || path13.resolve(workspace.directoryPath) !== directoryPath) {
+    fail("TARGET_ESCAPE", "\u81EA\u7531 Skill \u76EE\u6807\u76EE\u5F55\u5FC5\u987B\u662F workspace/.xg-platform");
+  }
+  let entry;
+  try {
+    entry = await io.lstat(directoryPath);
+  } catch (error) {
+    if (asErrnoCode(error) !== "ENOENT") {
+      fail("TARGET_UNAVAILABLE", `\u65E0\u6CD5\u68C0\u67E5\u81EA\u7531 Skill \u76EE\u6807\u76EE\u5F55: ${asMessage(error)}`);
+    }
+    try {
+      await io.mkdir(directoryPath, { recursive: false });
+      entry = await io.lstat(directoryPath);
+    } catch (mkdirError) {
+      if (asErrnoCode(mkdirError) !== "EEXIST") {
+        fail("ATOMIC_WRITE_FAILED", `\u521B\u5EFA\u81EA\u7531 Skill \u76EE\u6807\u76EE\u5F55\u5931\u8D25: ${asMessage(mkdirError)}`);
+      }
+      try {
+        entry = await io.lstat(directoryPath);
+      } catch (statError) {
+        fail("TARGET_UNAVAILABLE", `\u65E0\u6CD5\u68C0\u67E5\u81EA\u7531 Skill \u76EE\u6807\u76EE\u5F55: ${asMessage(statError)}`);
+      }
+    }
+  }
+  if (entry.isSymbolicLink()) fail("TARGET_SYMLINK", "\u62D2\u7EDD\u5199\u5165\u7B26\u53F7\u94FE\u63A5\u76EE\u6807\u76EE\u5F55");
+  if (!entry.isDirectory()) fail("TARGET_NOT_DIRECTORY", "\u81EA\u7531 Skill \u76EE\u6807\u4E0D\u662F\u76EE\u5F55");
+  let realDirectory;
+  try {
+    realDirectory = await io.realpath(directoryPath);
+  } catch (error) {
+    fail("TARGET_UNAVAILABLE", `\u65E0\u6CD5\u89E3\u6790\u81EA\u7531 Skill \u76EE\u6807\u76EE\u5F55: ${asMessage(error)}`);
+  }
+  if (realDirectory !== directoryPath || !isWithin3(workspacePath, realDirectory)) {
+    fail("TARGET_ESCAPE", "\u81EA\u7531 Skill \u76EE\u6807\u76EE\u5F55\u8D8A\u51FA Agent workspace");
+  }
+  return { workspacePath, directoryPath };
+}
+async function resolveWriterWorkspace(input, suppliedWorkspace, io) {
+  let workspace;
+  const candidate = suppliedWorkspace ?? input.workspace;
+  if (isResolvedWorkspace(candidate)) {
+    workspace = candidate;
+  } else {
+    const context = input.context ?? candidate ?? input;
+    try {
+      workspace = await resolveFreeSkillWorkspace(context);
+    } catch (error) {
+      if (error instanceof FreeSkillWorkspaceError) throw error;
+      fail("WORKSPACE_MISSING", `\u65E0\u6CD5\u89E3\u6790 Agent workspace: ${asMessage(error)}`);
+    }
+  }
+  return ensurePlatformDirectory(workspace, io);
+}
+function makeTemporaryPath(directoryPath, skillName, suffix) {
+  return path13.join(
+    directoryPath,
+    `.${skillName}.${suffix}-${process.pid}-${Date.now()}-${crypto.randomUUID()}`
+  );
+}
+async function removePath(io, target) {
+  await io.rm(target, { recursive: true, force: true }).catch(() => void 0);
+}
+async function targetAlreadyExists(targetPath, io) {
+  try {
+    const entry = await io.lstat(targetPath);
+    return entry.isSymbolicLink() ? "symlink" : "exists";
+  } catch (error) {
+    if (asErrnoCode(error) === "ENOENT") return "missing";
+    fail("TARGET_UNAVAILABLE", `\u65E0\u6CD5\u68C0\u67E5 Skill \u76EE\u6807\u76EE\u5F55: ${asMessage(error)}`);
+  }
+}
+async function writeFreeSkill(input, workspace, dependencies) {
+  const io = {
+    ...defaultFileSystem,
+    ...dependencies?.fileSystem
+  };
+  try {
+    if (!isRecord3(input)) fail("INVALID_CONTENT", "Skill \u5199\u5165\u8BF7\u6C42\u5FC5\u987B\u662F\u5BF9\u8C61");
+    const skillName = validateSkillName(input.skillName ?? input.name);
+    const content = input.content ?? input.skillContent;
+    validateFreeSkillContent(content);
+    const metadata = serializeMetadata(input.metadata);
+    const { directoryPath: platformDirectoryPath } = await resolveWriterWorkspace(input, workspace, io);
+    const targetDirectoryPath = path13.resolve(platformDirectoryPath, skillName);
+    if (!isWithin3(platformDirectoryPath, targetDirectoryPath)) {
+      fail("TARGET_ESCAPE", "Skill \u76EE\u6807\u76EE\u5F55\u8D8A\u51FA workspace/.xg-platform");
+    }
+    const existing = await targetAlreadyExists(targetDirectoryPath, io);
+    if (existing === "symlink") fail("TARGET_SYMLINK", "\u62D2\u7EDD\u5199\u5165\u7B26\u53F7\u94FE\u63A5 Skill \u76EE\u5F55");
+    if (existing === "exists") fail("SKILL_EXISTS", `Skill \u5DF2\u5B58\u5728: ${skillName}`);
+    let createdTargetDirectory = false;
+    let skillTempPath;
+    let metadataTempPath;
+    const skillFilePath = path13.join(targetDirectoryPath, SKILL_FILE_NAME2);
+    const metadataFilePath = metadata ? path13.join(targetDirectoryPath, ".meta.json") : void 0;
+    try {
+      try {
+        await io.mkdir(targetDirectoryPath, { recursive: false });
+        createdTargetDirectory = true;
+      } catch (error) {
+        if (asErrnoCode(error) === "EEXIST") {
+          const raced = await targetAlreadyExists(targetDirectoryPath, io);
+          if (raced === "symlink") fail("TARGET_SYMLINK", "\u62D2\u7EDD\u5199\u5165\u7B26\u53F7\u94FE\u63A5 Skill \u76EE\u5F55");
+          fail("SKILL_EXISTS", `Skill \u5DF2\u5B58\u5728: ${skillName}`);
+        }
+        fail("ATOMIC_WRITE_FAILED", `\u521B\u5EFA Skill \u76EE\u5F55\u5931\u8D25: ${asMessage(error)}`);
+      }
+      skillTempPath = makeTemporaryPath(targetDirectoryPath, skillName, "skill-md-tmp");
+      await io.writeFile(skillTempPath, content, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 384
+      });
+      await io.rename(skillTempPath, skillFilePath);
+      skillTempPath = void 0;
+      if (metadata && metadataFilePath) {
+        metadataTempPath = makeTemporaryPath(targetDirectoryPath, skillName, "metadata-tmp");
+        await io.writeFile(metadataTempPath, metadata, {
+          encoding: "utf8",
+          flag: "wx",
+          mode: 384
+        });
+        await io.rename(metadataTempPath, metadataFilePath);
+        metadataTempPath = void 0;
+      }
+    } catch (error) {
+      if (error instanceof FreeSkillWriterError && error.code === "SKILL_EXISTS") throw error;
+      await Promise.all([
+        skillTempPath ? removePath(io, skillTempPath) : Promise.resolve(),
+        metadataTempPath ? removePath(io, metadataTempPath) : Promise.resolve()
+      ]);
+      if (createdTargetDirectory) await removePath(io, targetDirectoryPath);
+      if (error instanceof FreeSkillWriterError) throw error;
+      fail("ATOMIC_WRITE_FAILED", `\u81EA\u7531 Skill \u539F\u5B50\u5199\u5165\u5931\u8D25: ${asMessage(error)}`);
+    }
+    return {
+      success: true,
+      skillName,
+      directoryPath: targetDirectoryPath,
+      skillFilePath,
+      ...metadataFilePath ? { metadataFilePath } : {}
+    };
+  } catch (error) {
+    if (error instanceof FreeSkillWriterError) {
+      return { success: false, code: error.code, message: error.message };
+    }
+    if (error instanceof FreeSkillWorkspaceError) {
+      return { success: false, code: error.code, message: error.message };
+    }
+    return { success: false, code: "ATOMIC_WRITE_FAILED", message: `\u81EA\u7531 Skill \u5199\u5165\u5931\u8D25: ${asMessage(error)}` };
+  }
+}
+async function writeFreeSkillOrThrow(input, workspace, dependencies) {
+  const result = await writeFreeSkill(input, workspace, dependencies);
+  if (!result.success) throw new FreeSkillWriterError(result.code, result.message);
+  return result;
+}
+
+// src/free-skill-tool.ts
+var FREE_SKILL_TOOL_NAME = "skill_logger_create_free_skill";
+var parameters = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    skillName: { type: "string", description: "\u81EA\u7531 Skill \u7684\u4E00\u7EA7\u76EE\u5F55\u540D" },
+    content: { type: "string", description: "\u5B8C\u6574\u7684 SKILL.md \u5185\u5BB9" },
+    metadata: { type: "object", description: "\u53EF\u9009\u7684 JSON \u5143\u6570\u636E" }
+  },
+  required: ["skillName", "content"]
+};
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function asInput(params) {
+  if (hasOwn(params, "target") || hasOwn(params, "path")) {
+    throw new FreeSkillWriterError(
+      "INVALID_CONTENT",
+      "\u81EA\u7531 Skill \u5DE5\u5177\u4E0D\u63A5\u53D7 target/path\uFF0C\u76EE\u6807\u8DEF\u5F84\u7531\u5F53\u524D Agent workspace \u51B3\u5B9A"
+    );
+  }
+  return {
+    skillName: params.skillName ?? params.name,
+    content: params.content ?? params.skillContent,
+    metadata: params.metadata
+  };
+}
+function createFreeSkillToolFactory(context) {
+  return {
+    name: FREE_SKILL_TOOL_NAME,
+    label: "Create free Skill",
+    description: "Create a validated Skill in the current Agent workspace under .xg-platform. The target path is runtime controlled.",
+    parameters,
+    async execute(_toolCallId, params) {
+      const workspace = await resolveFreeSkillWorkspace(context);
+      const result = await writeFreeSkillOrThrow(asInput(params), workspace);
+      const workspaceRelativePath = path14.posix.join(".xg-platform", result.skillName);
+      const details = {
+        success: true,
+        skillName: result.skillName,
+        workspaceRelativePath,
+        directoryPath: result.directoryPath,
+        skillFilePath: result.skillFilePath,
+        ...workspace.agentId ? { agentId: workspace.agentId } : {}
+      };
+      return {
+        content: [{ type: "text", text: `\u81EA\u7531 Skill \u5DF2\u5199\u5165 ${workspaceRelativePath}` }],
+        details
+      };
+    }
+  };
+}
+
 // src/index.ts
 var wsClient;
 var RECONCILE_INTERVAL_MS = 3 * 60 * 1e3;
@@ -5765,11 +6645,14 @@ var definition = {
   name: "Skill Logger",
   description: "\u8FFD\u8E2A openclaw skill \u5185\u529F\u80FD\u70B9\uFF08\u811A\u672C/\u547D\u4EE4/\u5DE5\u5177/HTTP\uFF09\u4F7F\u7528\u4E0E\u62A5\u9519\uFF0C\u843D\u672C\u5730\u5E76\u6279\u91CF\u4E0A\u62A5",
   register(api) {
+    if (typeof api.registerTool === "function") {
+      api.registerTool(createFreeSkillToolFactory, { name: FREE_SKILL_TOOL_NAME });
+    }
     let pkgVersion = "unknown";
     try {
-      const dir = path11.dirname(fileURLToPath2(import.meta.url));
-      const pkgPath = path11.join(dir, "..", "package.json");
-      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+      const dir = path15.dirname(fileURLToPath2(import.meta.url));
+      const pkgPath = path15.join(dir, "..", "package.json");
+      const pkg = JSON.parse(fs12.readFileSync(pkgPath, "utf-8"));
       if (pkg.version) pkgVersion = pkg.version;
     } catch {
     }