@workclaw/openclaw-workclaw 1.0.17 → 1.0.18

package/src/gateway/skills-handler.ts

@@ -4,158 +4,156 @@
  * 通过 HTTP 回调返回结果
  */
 
-import { Buffer } from 'node:buffer'
-import { exec } from 'node:child_process'
-import fs from 'node:fs/promises'
-import http from 'node:http'
-import https from 'node:https'
-import os from 'node:os'
-import path from 'node:path'
-import process from 'node:process'
-import { promisify } from 'node:util'
-
-const execAsync = promisify(exec)
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import https from "node:https";
+import http from "node:http";
+import zlib from "node:zlib";
+import stream from "node:stream";
+
+const execAsync = promisify(exec);
 
 export interface SkillsEventData {
-  topic: string // skills/create, skills/update, skills/delete, skills/list, skills/get, skills/invoke
-  requestId: string
-  callbackUrl: string
-  authToken?: string
-  data: any
+  topic: string; // skills/create, skills/update, skills/delete, skills/list, skills/get, skills/invoke
+  requestId: string;
+  callbackUrl: string;
+  authToken?: string;
+  data: any;
 }
 
 export interface CallbackResponse {
-  userId?: string
-  agentId?: string
-  agentIds?: string[]
-  appKey?: string
-  dotype?: string
-  doStatus?: boolean
-  doErrorMsg?: string
+  userId?: string,
+  agentId?: string,
+  agentIds?: string[],
+  appKey?: string,
+  dotype?: string,
+  doStatus?: boolean,
+  doErrorMsg?: string,
   dataList?: any[]
 }
 
 // 回调 URL 映射
 const TOPIC_TO_CALLBACK_URL: Record<string, string> = {
-  'skills/add': '/open-apis/v1/claw/do/skills/result',
-  'skills/update': '/open-apis/v1/claw/do/skills/result',
-  'skills/remove': '/open-apis/v1/claw/do/skills/result',
-  'skills/list': '/open-apis/v1/claw/do/skills/result',
-  'skills/get': '/open-apis/v1/claw/do/skills/result',
-  'skills/invoke': '/open-apis/v1/claw/do/skills/result',
-}
+  "skills/add": "/open-apis/v1/claw/do/skills/result",
+  "skills/update": "/open-apis/v1/claw/do/skills/result",
+  "skills/remove": "/open-apis/v1/claw/do/skills/result",
+  "skills/list": "/open-apis/v1/claw/do/skills/result",
+  "skills/get": "/open-apis/v1/claw/do/skills/result",
+  "skills/invoke": "/open-apis/v1/claw/do/skills/result",
+};
 
 /**
  * 处理 skills 事件
  */
 export async function handleSkillsEvent(
-  eventData: SkillsEventData,
-  token: string,
-  baseUrl: string,
-  appKey: string,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    eventData: SkillsEventData,
+    token: string,
+    baseUrl: string,
+    appKey: string,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    },
 ): Promise<void> {
-  const { topic, data } = eventData
-  log?.info?.(`[SkillsHandler] Processing ${topic}, data: ${JSON.stringify(data)}`)
+  const { topic, data } = eventData;
+  log?.info?.(`[SkillsHandler] Processing ${topic}, data: ${JSON.stringify(data)}`);
 
   try {
-    let result: any
+    let result: any;
 
     // 根据 topic 路由到不同的处理函数
     switch (topic) {
-      case 'skills/add':
-        result = await handleCreateSkill(data, log)
-        break
-      case 'skills/update':
-        result = await handleUpdateSkill(data, log)
-        break
-      case 'skills/remove':
-        result = await handleDeleteSkill(data, log)
-        break
-      case 'skills/list':
-        result = await handleListSkills(data, log)
-        break
-      case 'skills/get':
-        result = await handleGetSkill(data, log)
-        break
-      case 'skills/invoke':
-        result = await handleInvokeSkill(data, log)
-        break
+      case "skills/add":
+        result = await handleCreateSkill(data, log);
+        break;
+      case "skills/update":
+        result = await handleUpdateSkill(data, log);
+        break;
+      case "skills/remove":
+        result = await handleDeleteSkill(data, log);
+        break;
+      case "skills/list":
+        result = await handleListSkills(data, log);
+        break;
+      case "skills/get":
+        result = await handleGetSkill(data, log);
+        break;
+      case "skills/invoke":
+        result = await handleInvokeSkill(data, log);
+        break;
       default:
-        throw new Error(`Unknown topic: ${topic}`)
+        throw new Error(`Unknown topic: ${topic}`);
     }
 
     // 发送成功回调
     await sendCallback(
-      baseUrl,
-      topic,
-      {
-        userId: result.userId || '',
-        agentId: '',
-        appKey,
-        agentIds: Array.isArray(result.agentIds) ? result.agentIds : (result.agentIds || 0),
-        dotype: result.status || topic.split('/')[1],
-        doStatus: true,
-        doErrorMsg: '',
-        dataList: [
-          {
-            typeStr: '',
-            name: result.skillName || '',
-            description: '',
-          },
-        ],
-      },
-      token,
-      log,
-    )
-
-    log?.info?.(`[SkillsHandler] ${topic} completed, callback sent`)
+        baseUrl,
+        topic,
+        {
+          userId: result.userId || "",
+          agentId: "",
+          appKey,
+          agentIds: Array.isArray(result.agentIds) ? result.agentIds : (result.agentIds || 0),
+          dotype: result.status || topic.split('/')[1],
+          doStatus: true,
+          doErrorMsg: "",
+          dataList: [
+            {
+              typeStr: "",
+              name: result.skillName || "",
+              description: "",
+            }
+          ],
+        },
+        token,
+        log
+    );
+
+    log?.info?.(`[SkillsHandler] ${topic} completed, callback sent`);
 
     // 重启 OpenClaw 网关（仅在添加、更新、删除技能时）
     if (['skills/add', 'skills/update', 'skills/remove'].includes(topic)) {
       try {
-        log?.info?.(`[SkillsHandler] rescan...`)
-        await execAsync(`openclaw skills rescan`, { timeout: 2000 })
-        await execAsync(`openclaw skills reload --force`, { timeout: 2000 })
-        await execAsync(`openclaw skills list`, { timeout: 2000 })
-        log?.info?.(`[SkillsHandler] OpenClaw skills rescaned successfully`)
-      }
-      catch (err: any) {
-        log?.error?.(`[SkillsHandler] Failed to rescan OpenClaw skills: ${err.message}`)
+        log?.info?.(`[SkillsHandler] rescan...`);
+        await execAsync(`openclaw skills rescan`, { timeout: 2000 });
+        await execAsync(`openclaw skills reload --force`, { timeout: 2000 });
+        await execAsync(`openclaw skills list`, { timeout: 2000 });
+        log?.info?.(`[SkillsHandler] OpenClaw skills rescaned successfully`);
+      } catch (err: any) {
+        log?.error?.(`[SkillsHandler] Failed to rescan OpenClaw skills: ${err.message}`);
         // 重启 OpenClaw 网关
-        await execAsync(`openclaw skills restart`, { timeout: 20000 })
+        await execAsync(`openclaw skills restart`, { timeout: 20000 });
       }
     }
-  }
-  catch (err: any) {
-    log?.error?.(`[SkillsHandler] ${topic} failed: ${err.message}`)
+  } catch (err: any) {
+    log?.error?.(`[SkillsHandler] ${topic} failed: ${err.message}`);
 
     // 发送失败回调
     await sendCallback(
-      baseUrl,
-      topic,
-      {
-        userId: '',
-        agentId: '',
-        agentIds: [],
-        appKey,
-        dotype: topic.split('/')[1],
-        doStatus: false,
-        doErrorMsg: err.message,
-        dataList: [
-          {
-            typeStr: '',
-            name: '',
-            description: '',
-          },
-        ],
-      },
-      token,
-      log,
-    )
+        baseUrl,
+        topic,
+        {
+          userId: "",
+          agentId: "",
+          agentIds: [],
+          appKey,
+          dotype: topic.split("/")[1],
+          doStatus: false,
+          doErrorMsg: err.message,
+          dataList: [
+            {
+              typeStr: "",
+              name: "",
+              description: "",
+            }
+          ],
+        },
+        token,
+        log
+    );
   }
 }
 
@@ -163,512 +161,452 @@ export async function handleSkillsEvent(
  * 发送 HTTP 回调
  */
 async function sendCallback(
-  baseUrl: string,
-  topic: string,
-  response?: CallbackResponse,
-  authToken?: string,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    baseUrl: string,
+    topic: string,
+    response?: CallbackResponse,
+    authToken?: string,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<void> {
   // 获取回调 URL
-  const callbackPath = TOPIC_TO_CALLBACK_URL[topic]
+  const callbackPath = TOPIC_TO_CALLBACK_URL[topic];
   if (!callbackPath) {
-    throw new Error(`No callback URL defined for topic: ${topic}`)
+    throw new Error(`No callback URL defined for topic: ${topic}`);
   }
 
-  const callbackUrl = `${baseUrl.replace(/\/$/, '')}${callbackPath}`
-  const responseData = JSON.stringify(response)
+  const callbackUrl = `${baseUrl.replace(/\/$/, "")}${callbackPath}`;
+  const responseData = JSON.stringify(response);
 
-  log?.info?.(`[SkillsHandler] Sending callback to ${callbackUrl}, data: ${responseData}`)
+  log?.info?.(`[SkillsHandler] Sending callback to ${callbackUrl}, data: ${responseData}`);
 
   // 准备请求头
   const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-  }
+    "Content-Type": "application/json",
+  };
 
   if (authToken) {
-    headers.Authorization = authToken.startsWith('Bearer ')
-      ? authToken
-      : `Bearer ${authToken}`
+    headers["Authorization"] = authToken.startsWith("Bearer ")
+        ? authToken
+        : `Bearer ${authToken}`;
   }
 
   // 使用 AbortController 实现超时
-  const controller = new AbortController()
-  const timeoutId = setTimeout(() => controller.abort(), 30000)
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 30000);
 
   try {
     const res = await fetch(callbackUrl, {
-      method: 'POST',
+      method: "POST",
       headers,
       body: responseData,
       signal: controller.signal,
-    })
+    });
 
-    clearTimeout(timeoutId)
+    clearTimeout(timeoutId);
 
     if (!res.ok) {
-      const errorText = await res.text()
-      throw new Error(`HTTP ${res.status}: ${res.statusText || errorText}`)
+      const errorText = await res.text();
+      throw new Error(`HTTP ${res.status}: ${res.statusText || errorText}`);
     }
 
-    log?.info?.(`[SkillsHandler] Callback sent successfully, status: ${res.status}`)
-  }
-  catch (err: any) {
-    clearTimeout(timeoutId)
+    log?.info?.(`[SkillsHandler] Callback sent successfully, status: ${res.status}`);
+  } catch (err: any) {
+    clearTimeout(timeoutId);
 
-    if (err.name === 'AbortError') {
-      log?.error?.(`[SkillsHandler] Callback timeout after 30s: ${callbackUrl}`)
-      throw new Error('Callback timeout')
+    if (err.name === "AbortError") {
+      log?.error?.(`[SkillsHandler] Callback timeout after 30s: ${callbackUrl}`);
+      throw new Error("Callback timeout");
     }
 
-    log?.error?.(`[SkillsHandler] Failed to send callback: ${err.message}`)
-    throw err
+    log?.error?.(`[SkillsHandler] Failed to send callback: ${err.message}`);
+    throw err;
   }
 }
 
 /**
  * 从 URL 下载文件内容
  */
-async function downloadFromUrl(url: string): Promise<Buffer> {
+async function downloadFromUrl(url: string, log?: any): Promise<Buffer> {
   return new Promise((resolve, reject) => {
-    const client = url.startsWith('https:') ? https : http
+    const client = url.startsWith("https:") ? https : http;
 
     const req = client.get(url, (res) => {
       if (res.statusCode !== 200) {
-        reject(new Error(`Failed to download: HTTP ${res.statusCode}`))
-        return
+        reject(new Error(`Failed to download: HTTP ${res.statusCode}`));
+        return;
       }
 
-      const chunks: Buffer[] = []
-      res.on('data', (chunk) => {
-        chunks.push(chunk)
-      })
-      res.on('end', () => {
-        const buffer = Buffer.concat(chunks)
-        resolve(buffer)
-      })
-    })
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk) => {
+        chunks.push(chunk);
+      });
+      res.on("end", () => {
+        const buffer = Buffer.concat(chunks);
+        resolve(buffer);
+      });
+    });
 
-    req.on('error', (err) => {
-      reject(new Error(`Download failed: ${err.message}`))
-    })
+    req.on("error", (err) => {
+      reject(new Error(`Download failed: ${err.message}`));
+    });
 
     req.setTimeout(30000, () => {
-      req.destroy()
-      reject(new Error('Download timeout'))
-    })
-  })
+      req.destroy();
+      reject(new Error("Download timeout"));
+    });
+  });
 }
 
 /**
  * 获取 OpenClaw 配置目录
  */
 function getOpenClawConfigDir(): string {
-  const homeDir = os.homedir()
-  return path.join(homeDir, '.openclaw')
+  const homeDir = os.homedir();
+  return path.join(homeDir, ".openclaw");
 }
 
 /**
  * 获取 skills 目录
  */
 async function getSkillsDir(agentId?: string, log?: any): Promise<string> {
-  const openclawDir = getOpenClawConfigDir()
-  let skillsDir = path.join(openclawDir, 'workspace', 'skills')
+  const openclawDir = getOpenClawConfigDir();
+  let skillsDir = path.join(openclawDir, "skills");
 
   // 如果有 agentId，添加到对应目录
   if (agentId && agentId.trim()) {
-    skillsDir = path.join(openclawDir, `workspace-${agentId}`, 'skills')
+    skillsDir = path.join(openclawDir, "agents", `openclaw-workclaw-${agentId}`, "skills");
   }
 
   try {
-    await fs.mkdir(skillsDir, { recursive: true })
-  }
-  catch (err: any) {
-    log?.error?.(`[SkillsHandler] Failed to create skills directory: ${err.message}`)
-    throw new Error(`Failed to create skills directory: ${err.message}`)
+    await fs.mkdir(skillsDir, { recursive: true });
+  } catch (err: any) {
+    log?.error?.(`[SkillsHandler] Failed to create skills directory: ${err.message}`);
+    throw new Error(`Failed to create skills directory: ${err.message}`);
   }
 
-  return skillsDir
+  return skillsDir;
 }
 
 /**
  * 安装 skill 到 OpenClaw
  */
 async function installSkillToClaw(
-  skillName: string,
-  skillContent: Buffer,
-  agentId?: string,
-  log?: any,
-): Promise<{ success: boolean, message: string, path?: string }> {
+    skillName: string,
+    skillContent: Buffer,
+    agentId?: string,
+    log?: any
+): Promise<{ success: boolean; message: string; path?: string }> {
   try {
     // 检测是否为 ZIP 文件（ZIP 文件以 PK 开头）
-    const isZip = skillContent.toString('utf8', 0, 2) === 'PK'
+    const isZip = skillContent.toString('utf8', 0, 2) === 'PK';
 
     if (isZip) {
-      log?.info?.(`[SkillsHandler] Detected ZIP file, extracting...`)
+      log?.info?.(`[SkillsHandler] Detected ZIP file, extracting...`);
 
       // 获取 skills 目录
-      const skillsDir = await getSkillsDir(agentId, log)
+      const skillsDir = await getSkillsDir(agentId, log);
       // 创建以 skillName 命名的目录
-      const skillDir = path.join(skillsDir, skillName)
-      const tempZipPath = path.join(skillsDir, `${skillName}.zip`)
+      const skillDir = path.join(skillsDir, skillName);
+      const tempZipPath = path.join(skillsDir, `${skillName}.zip`);
 
       try {
         // 创建技能目录
-        await fs.mkdir(skillDir, { recursive: true })
-        log?.info?.(`[SkillsHandler] Skill directory created: ${skillDir}`)
+        await fs.mkdir(skillDir, { recursive: true });
+        log?.info?.(`[SkillsHandler] Skill directory created: ${skillDir}`);
 
         // 写入临时 ZIP 文件
-        await fs.writeFile(tempZipPath, skillContent)
-        log?.info?.(`[SkillsHandler] Temporary ZIP file created: ${tempZipPath}`)
+        await fs.writeFile(tempZipPath, skillContent);
+        log?.info?.(`[SkillsHandler] Temporary ZIP file created: ${tempZipPath}`);
 
         // 解压 ZIP 文件到技能目录
         if (process.platform === 'win32') {
           // Windows 系统使用 PowerShell 解压
-          await execAsync(`powershell -Command "Expand-Archive -Path '${tempZipPath}' -DestinationPath '${skillDir}' -Force"`)
-        }
-        else {
+          await execAsync(`powershell -Command "Expand-Archive -Path '${tempZipPath}' -DestinationPath '${skillDir}' -Force"`);
+        } else {
           // Unix-like 系统使用 unzip 命令
-          await execAsync(`unzip -o '${tempZipPath}' -d '${skillDir}'`)
+          await execAsync(`unzip -o '${tempZipPath}' -d '${skillDir}'`);
         }
 
-        log?.info?.(`[SkillsHandler] ZIP file extracted successfully to: ${skillDir}`)
+        log?.info?.(`[SkillsHandler] ZIP file extracted successfully to: ${skillDir}`);
 
         // 删除临时 ZIP 文件
-        await fs.unlink(tempZipPath)
-        log?.info?.(`[SkillsHandler] Temporary ZIP file deleted`)
+        await fs.unlink(tempZipPath);
+        log?.info?.(`[SkillsHandler] Temporary ZIP file deleted`);
 
         return {
           success: true,
           message: `ZIP skill package ${skillName} installed successfully`,
           path: skillDir,
-        }
-      }
-      catch (err: any) {
-        log?.error?.(`[SkillsHandler] Failed to extract ZIP file: ${err.message}`)
+        };
+      } catch (err: any) {
+        log?.error?.(`[SkillsHandler] Failed to extract ZIP file: ${err.message}`);
         // 清理临时文件和目录
         try {
-          await fs.unlink(tempZipPath)
-        }
-        catch {}
+          await fs.unlink(tempZipPath);
+        } catch {}
         try {
-          await fs.rm(skillDir, { recursive: true, force: true })
-        }
-        catch {}
+          await fs.rm(skillDir, { recursive: true, force: true });
+        } catch {}
         return {
           success: false,
           message: `Failed to extract ZIP file: ${err.message}`,
-        }
+        };
       }
     }
 
     // 尝试解析为 JSON
-    let skillData: any
+    let skillData: any;
     try {
-      const jsonString = skillContent.toString('utf8')
-      skillData = JSON.parse(jsonString)
-    }
-    catch (err: any) {
+      const jsonString = skillContent.toString('utf8');
+      skillData = JSON.parse(jsonString);
+    } catch (err: any) {
       return {
         success: false,
         message: `Invalid skill JSON: ${err.message}`,
-      }
+      };
     }
 
     // 验证必要的字段
     if (!skillData.id || !skillData.name) {
       return {
         success: false,
-        message: 'Missing required fields in skill: id, name',
-      }
+        message: "Missing required fields in skill: id, name",
+      };
     }
 
     // 获取 skills 目录
-    const skillsDir = await getSkillsDir(agentId, log)
-    const skillFilePath = path.join(skillsDir, `${skillName}.json`)
+    const skillsDir = await getSkillsDir(agentId, log);
+    const skillFilePath = path.join(skillsDir, `${skillName}.json`);
 
     // 写入 skill 文件
-    await fs.writeFile(skillFilePath, skillContent, 'utf-8')
-    log?.info?.(`[SkillsHandler] Skill saved to: ${skillFilePath}`)
+    await fs.writeFile(skillFilePath, skillContent, "utf-8");
+    log?.info?.(`[SkillsHandler] Skill saved to: ${skillFilePath}`);
 
     return {
       success: true,
       message: `Skill ${skillName} installed successfully`,
       path: skillFilePath,
-    }
-  }
-  catch (err: any) {
+    };
+  } catch (err: any) {
     return {
       success: false,
       message: `Failed to install skill: ${err.message}`,
-    }
+    };
   }
 }
 
 /**
  * 创建 Skill
  */
-async function installSkillToLocations(skillName: string, skillContent: Buffer, locations: (string | undefined)[], log?: any): Promise<any[]> {
-  const installResults = []
-
-  for (const agentId of locations) {
-    const installResult = await installSkillToClaw(skillName, skillContent, agentId, log)
-    if (!installResult.success) {
-      const error: any = new Error(`Failed to install skill to ${agentId ? `agent ${agentId}` : 'default location'}: ${installResult.message}`)
-      error.code = 'INSTALL_FAILED'
-      throw error
-    }
-    installResults.push(installResult)
-  }
-
-  return installResults
-}
-
 async function handleCreateSkill(
-  data: any,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    data: any,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<any> {
-  const { userId, skillName, unloadUrl, mainId } = data
-  const agentIds = Array.isArray(data?.agentIds) ? data.agentIds : (data?.agentIds ? [data.agentIds] : [])
+  const { userId, skillName, unloadUrl } = data;
+  const agentIds = Array.isArray(data?.agentIds) ? data.agentIds : (data?.agentIds ? [data.agentIds] : []);
 
   if (!userId || !skillName) {
-    const error: any = new Error('Missing required fields: userId, skillName')
-    error.code = 'MISSING_FIELDS'
-    throw error
+    const error: any = new Error("Missing required fields: userId, skillName");
+    error.code = "MISSING_FIELDS";
+    throw error;
   }
 
-  log?.info?.(`[SkillsHandler] Creating skill: ${skillName}`)
-  log?.info?.(`[SkillsHandler] mainId: ${mainId}`)
+  log?.info?.(`[SkillsHandler] Creating skill: ${skillName}`);
   if (agentIds.length > 0) {
-    log?.info?.(`[SkillsHandler] Target agents: ${agentIds.join(', ')}`)
+    log?.info?.(`[SkillsHandler] Target agents: ${agentIds.join(", ")}`);
   }
 
   // 如果提供了 URL，从 URL 下载 skill 定义
   if (unloadUrl) {
-    log?.info?.(`[SkillsHandler] Downloading skill from URL: ${unloadUrl}`)
+    log?.info?.(`[SkillsHandler] Downloading skill from URL: ${unloadUrl}`);
 
     try {
       // 下载 skill 定义
-      const skillContent = await downloadFromUrl(unloadUrl)
-      log?.info?.(`[SkillsHandler] Downloaded skill content, length: ${skillContent.length} bytes`)
-
-      // 确定安装位置
-      const installLocations: (string | undefined)[] = []
-
-      // 检查 agentIds 是否只包含 mainId
-      const hasOnlyMainId = agentIds.length === 1 && agentIds[0] === mainId
-      // 检查 agentIds 是否包含 mainId 和其他 id
-      const hasMainIdAndOthers = agentIds.includes(mainId) && agentIds.length > 1
-
-      if (hasOnlyMainId) {
-        // 如果只有 mainId，安装到默认位置
-        log?.info?.(`[SkillsHandler] Only mainId found, installing to default location`)
-        installLocations.push(undefined)
-      }
-      else if (hasMainIdAndOthers) {
-        // 如果有 mainId 和其他 id，安装到默认位置和其他 id 位置
-        log?.info?.(`[SkillsHandler] mainId and other agents found, installing to default location and other agents`)
-        installLocations.push(undefined)
-        // 添加其他 id 位置（排除 mainId）
-        installLocations.push(...agentIds.filter((id: any) => id !== mainId))
-      }
-      else if (agentIds.length > 0) {
-        // 如果没有 mainId，安装到所有指定的 agentId 位置
-        log?.info?.(`[SkillsHandler] No mainId found, installing to all specified agents`)
-        installLocations.push(...agentIds)
-      }
-      else {
-        // 如果没有指定智能体，安装到默认位置
-        log?.info?.(`[SkillsHandler] No agents specified, installing to default location`)
-        installLocations.push(undefined)
+      const skillContent = await downloadFromUrl(unloadUrl, log);
+      log?.info?.(`[SkillsHandler] Downloaded skill content, length: ${skillContent.length} bytes`);
+
+      // 安装 skill 到多个智能体
+      const installResults = [];
+      for (const agentId of agentIds) {
+        const installResult = await installSkillToClaw(skillName, skillContent, agentId, log);
+        if (!installResult.success) {
+          const error: any = new Error(`Failed to install skill to agent ${agentId}: ${installResult.message}`);
+          error.code = "INSTALL_FAILED";
+          throw error;
+        }
+        installResults.push(installResult);
       }
 
-      // 安装技能到所有位置
-      const installResults = await installSkillToLocations(skillName, skillContent, installLocations, log)
+      // 如果没有指定智能体，安装到默认位置
+      if (agentIds.length === 0) {
+        const installResult = await installSkillToClaw(skillName, skillContent, undefined, log);
+        if (!installResult.success) {
+          const error: any = new Error(installResult.message);
+          error.code = "INSTALL_FAILED";
+          throw error;
+        }
+        installResults.push(installResult);
+      }
 
-      log?.info?.(`[SkillsHandler] Skill installed to ${installResults.length} locations`)
+      log?.info?.(`[SkillsHandler] Skill installed to ${installResults.length} locations`);
 
       return {
         userId,
         skillName,
-        agentId: '',
+        agentId: "",
         agentIds: agentIds.length > 0 ? agentIds : undefined,
-        status: 'add',
+        status: "add",
         installedAt: new Date().toISOString(),
-      }
-    }
-    catch (err: any) {
-      log?.error?.(`[SkillsHandler] Failed to create skill from URL: ${err.message}`)
-      throw err
+      };
+    } catch (err: any) {
+      log?.error?.(`[SkillsHandler] Failed to create skill from URL: ${err.message}`);
+      throw err;
     }
   }
 
   return {
     userId,
     skillName,
-    agentId: '',
+    agentId: "",
     agentIds: agentIds.length > 0 ? agentIds : undefined,
-    status: 'add',
+    status: "add",
     createdAt: new Date().toISOString(),
-  }
+  };
 }
 
 /**
  * 更新 Skill
  */
 async function handleUpdateSkill(
-  data: any,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    data: any,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<any> {
-  const { id, ...updates } = data
+  const { id, ...updates } = data;
 
   if (!id) {
-    const error: any = new Error('Missing required field: id')
-    error.code = 'MISSING_FIELDS'
-    throw error
+    const error: any = new Error("Missing required field: id");
+    error.code = "MISSING_FIELDS";
+    throw error;
   }
 
-  log?.info?.(`[SkillsHandler] Updating skill: ${id}`)
+  log?.info?.(`[SkillsHandler] Updating skill: ${id}`);
 
   return {
     id,
     ...updates,
-    status: 'updated',
+    status: "updated",
     updatedAt: new Date().toISOString(),
-  }
+  };
 }
 
 /**
  * 删除 Skill
  */
-async function deleteSkillAtLocation(skillName: string, agentId: string | undefined, log?: any): Promise<boolean> {
-  try {
-    const skillsDir = await getSkillsDir(agentId, log)
-
-    const skillFilePath = path.join(skillsDir, `${skillName}.json`)
-    const skillDirPath = path.join(skillsDir, skillName)
-
-    let deleted = false
-
-    // 尝试删除技能文件
-    try {
-      await fs.unlink(skillFilePath)
-      log?.info?.(`[SkillsHandler] Skill file deleted: ${skillFilePath}`)
-      deleted = true
-    }
-    catch {
-      // 文件不存在，继续尝试删除目录
-    }
-
-    // 尝试删除技能目录（ZIP 安装的技能）
-    try {
-      await fs.rm(skillDirPath, { recursive: true, force: true })
-      log?.info?.(`[SkillsHandler] Skill directory deleted: ${skillDirPath}`)
-      deleted = true
-    }
-    catch {
-      // 目录不存在，继续
-    }
-
-    return deleted
-  }
-  catch (err: any) {
-    log?.error?.(`[SkillsHandler] Failed to delete skill at location: ${err.message}`)
-    return false
-  }
-}
-
 async function handleDeleteSkill(
-  data: any,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    data: any,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<any> {
-  const { userId, skillName, agentIds, mainId } = data
-  const agentIdsList = Array.isArray(agentIds) ? agentIds : (agentIds ? [agentIds] : [])
+  const { userId, skillName, agentIds } = data;
+  const agentIdsList = Array.isArray(agentIds) ? agentIds : (agentIds ? [agentIds] : []);
 
   if (!skillName) {
-    const error: any = new Error('Missing required field: skillName')
-    error.code = 'MISSING_FIELDS'
-    throw error
+    const error: any = new Error("Missing required field: skillName");
+    error.code = "MISSING_FIELDS";
+    throw error;
   }
 
-  log?.info?.(`[SkillsHandler] Deleting skill: ${skillName}`)
-  log?.info?.(`[SkillsHandler] mainId: ${mainId}`)
+  log?.info?.(`[SkillsHandler] Deleting skill: ${skillName}`);
   if (agentIdsList.length > 0) {
-    log?.info?.(`[SkillsHandler] Target agents: ${agentIdsList.join(', ')}`)
+    log?.info?.(`[SkillsHandler] Target agents: ${agentIdsList.join(", ")}`);
   }
 
   try {
-    let deleted = false
+    let deleted = false;
 
-    // 检查 agentIds 是否只包含 mainId
-    const hasOnlyMainId = agentIdsList.length === 1 && agentIdsList[0] === mainId
-    // 检查 agentIds 是否包含 mainId 和其他 id
-    const hasMainIdAndOthers = agentIdsList.includes(mainId) && agentIdsList.length > 1
+    // 从多个智能体中删除技能
+    for (const agentId of agentIdsList) {
+      // 获取技能目录
+      const skillsDir = await getSkillsDir(agentId, log);
 
-    if (hasOnlyMainId) {
-      // 如果只有 mainId，从默认位置删除
-      log?.info?.(`[SkillsHandler] Only mainId found, deleting from default location`)
-      deleted = await deleteSkillAtLocation(skillName, undefined, log)
-    }
-    else if (hasMainIdAndOthers) {
-      // 如果有 mainId 和其他 id，从默认位置和其他 id 位置删除
-      log?.info?.(`[SkillsHandler] mainId and other agents found, deleting from default location and other agents`)
-
-      // 从默认位置删除
-      const defaultDeleted = await deleteSkillAtLocation(skillName, undefined, log)
-      deleted = deleted || defaultDeleted
-
-      // 从其他 id 位置删除（排除 mainId）
-      for (const agentId of agentIdsList) {
-        if (agentId !== mainId) {
-          const agentDeleted = await deleteSkillAtLocation(skillName, agentId, log)
-          deleted = deleted || agentDeleted
-        }
+      // 检查技能文件和目录
+      const skillFilePath = path.join(skillsDir, `${skillName}.json`);
+      const skillDirPath = path.join(skillsDir, skillName);
+
+      // 尝试删除技能文件
+      try {
+        await fs.unlink(skillFilePath);
+        log?.info?.(`[SkillsHandler] Skill file deleted: ${skillFilePath}`);
+        deleted = true;
+      } catch (err: any) {
+        // 文件不存在，继续尝试删除目录
       }
-    }
-    else if (agentIdsList.length > 0) {
-      // 如果没有 mainId，从所有指定的 agentId 位置删除
-      log?.info?.(`[SkillsHandler] No mainId found, deleting from all specified agents`)
-      for (const agentId of agentIdsList) {
-        const agentDeleted = await deleteSkillAtLocation(skillName, agentId, log)
-        deleted = deleted || agentDeleted
+
+      // 尝试删除技能目录（ZIP 安装的技能）
+      try {
+        await fs.rm(skillDirPath, { recursive: true, force: true });
+        log?.info?.(`[SkillsHandler] Skill directory deleted: ${skillDirPath}`);
+        deleted = true;
+      } catch (err: any) {
+        // 目录不存在，继续
       }
     }
-    else {
-      // 如果没有指定智能体，从默认位置删除
-      log?.info?.(`[SkillsHandler] No agents specified, deleting from default location`)
-      deleted = await deleteSkillAtLocation(skillName, undefined, log)
+
+    // 如果没有指定智能体，从默认位置删除
+    if (agentIdsList.length === 0) {
+      // 获取默认技能目录
+      const skillsDir = await getSkillsDir(undefined, log);
+
+      // 检查技能文件和目录
+      const skillFilePath = path.join(skillsDir, `${skillName}.json`);
+      const skillDirPath = path.join(skillsDir, skillName);
+
+      // 尝试删除技能文件
+      try {
+        await fs.unlink(skillFilePath);
+        log?.info?.(`[SkillsHandler] Skill file deleted: ${skillFilePath}`);
+        deleted = true;
+      } catch (err: any) {
+        // 文件不存在，继续尝试删除目录
+      }
+
+      // 尝试删除技能目录（ZIP 安装的技能）
+      try {
+        await fs.rm(skillDirPath, { recursive: true, force: true });
+        log?.info?.(`[SkillsHandler] Skill directory deleted: ${skillDirPath}`);
+        deleted = true;
+      } catch (err: any) {
+        // 目录不存在，继续
+      }
     }
 
     if (!deleted) {
-      const error: any = new Error(`Skill not found: ${skillName}`)
-      error.code = 'SKILL_NOT_FOUND'
-      throw error
+      const error: any = new Error(`Skill not found: ${skillName}`);
+      error.code = "SKILL_NOT_FOUND";
+      throw error;
     }
 
     return {
       userId,
       skillName,
-      agentId: '',
+      agentId: "",
       agentIds: agentIdsList.length > 0 ? agentIdsList : undefined,
-      status: 'remove',
+      status: "remove",
       deletedAt: new Date().toISOString(),
-    }
-  }
-  catch (err: any) {
-    log?.error?.(`[SkillsHandler] Failed to delete skill: ${err.message}`)
-    throw err
+    };
+  } catch (err: any) {
+    log?.error?.(`[SkillsHandler] Failed to delete skill: ${err.message}`);
+    throw err;
   }
 }
 
@@ -676,67 +614,65 @@ async function handleDeleteSkill(
  * 查询 Skills 列表
  */
 async function handleListSkills(
-  data: any,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    data: any,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<any> {
-  const { filter, limit = 100 } = data
+  const { filter, limit = 100 } = data;
 
-  log?.info?.(`[SkillsHandler] Listing skills, filter: ${filter}, limit: ${limit}`)
+  log?.info?.(`[SkillsHandler] Listing skills, filter: ${filter}, limit: ${limit}`);
 
   try {
     // 调用 openclaw skills list 命令
-    const { stdout } = await execAsync('openclaw skills list --json', {
+    const { stdout } = await execAsync("openclaw skills list --json", {
       timeout: 10000,
-    })
+    });
 
-    let skills: any[] = []
+    let skills: any[] = [];
     try {
-      const parsed = JSON.parse(stdout)
-      skills = parsed.skills || parsed
-    }
-    catch {
+      const parsed = JSON.parse(stdout);
+      skills = parsed.skills || parsed;
+    } catch {
       // 解析文本输出
-      const lines = stdout.split('\n')
+      const lines = stdout.split("\n");
       skills = lines
-        .filter(line => line.trim() && !line.includes('Skills'))
-        .map((line) => {
-          const parts = line.split(/\s{2,}/).map(p => p.trim())
-          if (parts.length >= 3) {
-            return {
-              status: parts[0]?.includes('✓') ? 'ready' : 'missing',
-              name: parts[1],
-              description: parts[2],
-              source: parts[3] || 'openclaw-bundled',
+          .filter((line) => line.trim() && !line.includes("Skills"))
+          .map((line) => {
+            const parts = line.split(/\s{2,}/).map((p) => p.trim());
+            if (parts.length >= 3) {
+              return {
+                status: parts[0]?.includes("✓") ? "ready" : "missing",
+                name: parts[1],
+                description: parts[2],
+                source: parts[3] || "openclaw-bundled",
+              };
             }
-          }
-          return null
-        })
-        .filter((s): s is any => s !== null)
+            return null;
+          })
+          .filter((s): s is any => s !== null);
     }
 
     // 应用过滤
     if (filter) {
-      skills = skills.filter(s => s.status === filter)
+      skills = skills.filter((s) => s.status === filter);
     }
 
     // 应用 limit
-    skills = skills.slice(0, limit)
+    skills = skills.slice(0, limit);
 
     return {
       total: skills.length,
       skills,
-    }
-  }
-  catch (err: any) {
-    log?.error?.(`[SkillsHandler] Failed to list skills: ${err.message}`)
+    };
+  } catch (err: any) {
+    log?.error?.(`[SkillsHandler] Failed to list skills: ${err.message}`);
     // 返回空列表而不是报错
     return {
       total: 0,
       skills: [],
-    }
+    };
   }
 }
 
@@ -744,62 +680,62 @@ async function handleListSkills(
  * 查询单个 Skill
  */
 async function handleGetSkill(
-  data: any,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    data: any,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<any> {
-  const { id } = data
+  const { id } = data;
 
   if (!id) {
-    const error: any = new Error('Missing required field: id')
-    error.code = 'MISSING_FIELDS'
-    throw error
+    const error: any = new Error("Missing required field: id");
+    error.code = "MISSING_FIELDS";
+    throw error;
   }
 
-  log?.info?.(`[SkillsHandler] Getting skill: ${id}`)
+  log?.info?.(`[SkillsHandler] Getting skill: ${id}`);
 
   // TODO: 实现实际的 skill 查询逻辑
 
   return {
     id,
     name: `Skill ${id}`,
-    description: 'Skill description',
-    status: 'ready',
-  }
+    description: "Skill description",
+    status: "ready",
+  };
 }
 
 /**
  * 执行 Skill
  */
 async function handleInvokeSkill(
-  data: any,
-  log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
-  },
+    data: any,
+    log?: {
+      info?: (msg: string) => void;
+      error?: (msg: string) => void;
+    }
 ): Promise<any> {
-  const { id, input, context } = data
+  const { id, input, context } = data;
 
   if (!id) {
-    const error: any = new Error('Missing required field: id')
-    error.code = 'MISSING_FIELDS'
-    throw error
+    const error: any = new Error("Missing required field: id");
+    error.code = "MISSING_FIELDS";
+    throw error;
   }
 
-  log?.info?.(`[SkillsHandler] Invoking skill: ${id}`)
+  log?.info?.(`[SkillsHandler] Invoking skill: ${id}`);
 
   // TODO: 实现实际的 skill 执行逻辑
 
   return {
     id,
-    status: 'completed',
+    status: "completed",
     output: {
       result: `Skill ${id} executed successfully`,
       input,
       context,
     },
     executedAt: new Date().toISOString(),
-  }
-}
+  };
+}