@workclaw/openclaw-workclaw 1.0.18 → 1.0.19

package/dist/src/gateway/skills-handler.js

@@ -0,0 +1,576 @@
+/**
+ * Skills 事件处理器
+ * 处理云端下发的 skills 相关 EVENT 消息
+ * 通过 HTTP 回调返回结果
+ */
+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";
+const execAsync = promisify(exec);
+// 回调 URL 映射
+const TOPIC_TO_CALLBACK_URL = {
+    "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, token, baseUrl, appKey, log) {
+    const { topic, data } = eventData;
+    log?.info?.(`[SkillsHandler] Processing ${topic}, data: ${JSON.stringify(data)}`);
+    try {
+        let result;
+        // 根据 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;
+            default:
+                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`);
+        // 重启 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) {
+                log?.error?.(`[SkillsHandler] Failed to rescan OpenClaw skills: ${err.message}`);
+                // 重启 OpenClaw 网关
+                await execAsync(`openclaw skills restart`, { timeout: 20000 });
+            }
+        }
+    }
+    catch (err) {
+        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);
+    }
+}
+/**
+ * 发送 HTTP 回调
+ */
+async function sendCallback(baseUrl, topic, response, authToken, log) {
+    // 获取回调 URL
+    const callbackPath = TOPIC_TO_CALLBACK_URL[topic];
+    if (!callbackPath) {
+        throw new Error(`No callback URL defined for topic: ${topic}`);
+    }
+    const callbackUrl = `${baseUrl.replace(/\/$/, "")}${callbackPath}`;
+    const responseData = JSON.stringify(response);
+    log?.info?.(`[SkillsHandler] Sending callback to ${callbackUrl}, data: ${responseData}`);
+    // 准备请求头
+    const headers = {
+        "Content-Type": "application/json",
+    };
+    if (authToken) {
+        headers["Authorization"] = authToken.startsWith("Bearer ")
+            ? authToken
+            : `Bearer ${authToken}`;
+    }
+    // 使用 AbortController 实现超时
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30000);
+    try {
+        const res = await fetch(callbackUrl, {
+            method: "POST",
+            headers,
+            body: responseData,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!res.ok) {
+            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) {
+        clearTimeout(timeoutId);
+        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;
+    }
+}
+/**
+ * 从 URL 下载文件内容
+ */
+async function downloadFromUrl(url, log) {
+    return new Promise((resolve, reject) => {
+        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;
+            }
+            const chunks = [];
+            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.setTimeout(30000, () => {
+            req.destroy();
+            reject(new Error("Download timeout"));
+        });
+    });
+}
+/**
+ * 获取 OpenClaw 配置目录
+ */
+function getOpenClawConfigDir() {
+    const homeDir = os.homedir();
+    return path.join(homeDir, ".openclaw");
+}
+/**
+ * 获取 skills 目录
+ */
+async function getSkillsDir(agentId, log) {
+    const openclawDir = getOpenClawConfigDir();
+    let skillsDir = path.join(openclawDir, "skills");
+    // 如果有 agentId，添加到对应目录
+    if (agentId && agentId.trim()) {
+        skillsDir = path.join(openclawDir, "agents", `openclaw-workclaw-${agentId}`, "skills");
+    }
+    try {
+        await fs.mkdir(skillsDir, { recursive: true });
+    }
+    catch (err) {
+        log?.error?.(`[SkillsHandler] Failed to create skills directory: ${err.message}`);
+        throw new Error(`Failed to create skills directory: ${err.message}`);
+    }
+    return skillsDir;
+}
+/**
+ * 安装 skill 到 OpenClaw
+ */
+async function installSkillToClaw(skillName, skillContent, agentId, log) {
+    try {
+        // 检测是否为 ZIP 文件（ZIP 文件以 PK 开头）
+        const isZip = skillContent.toString('utf8', 0, 2) === 'PK';
+        if (isZip) {
+            log?.info?.(`[SkillsHandler] Detected ZIP file, extracting...`);
+            // 获取 skills 目录
+            const skillsDir = await getSkillsDir(agentId, log);
+            // 创建以 skillName 命名的目录
+            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}`);
+                // 写入临时 ZIP 文件
+                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 {
+                    // Unix-like 系统使用 unzip 命令
+                    await execAsync(`unzip -o '${tempZipPath}' -d '${skillDir}'`);
+                }
+                log?.info?.(`[SkillsHandler] ZIP file extracted successfully to: ${skillDir}`);
+                // 删除临时 ZIP 文件
+                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) {
+                log?.error?.(`[SkillsHandler] Failed to extract ZIP file: ${err.message}`);
+                // 清理临时文件和目录
+                try {
+                    await fs.unlink(tempZipPath);
+                }
+                catch { }
+                try {
+                    await fs.rm(skillDir, { recursive: true, force: true });
+                }
+                catch { }
+                return {
+                    success: false,
+                    message: `Failed to extract ZIP file: ${err.message}`,
+                };
+            }
+        }
+        // 尝试解析为 JSON
+        let skillData;
+        try {
+            const jsonString = skillContent.toString('utf8');
+            skillData = JSON.parse(jsonString);
+        }
+        catch (err) {
+            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",
+            };
+        }
+        // 获取 skills 目录
+        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}`);
+        return {
+            success: true,
+            message: `Skill ${skillName} installed successfully`,
+            path: skillFilePath,
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: `Failed to install skill: ${err.message}`,
+        };
+    }
+}
+/**
+ * 创建 Skill
+ */
+async function handleCreateSkill(data, log) {
+    const { userId, skillName, unloadUrl } = data;
+    const agentIds = Array.isArray(data?.agentIds) ? data.agentIds : (data?.agentIds ? [data.agentIds] : []);
+    if (!userId || !skillName) {
+        const error = new Error("Missing required fields: userId, skillName");
+        error.code = "MISSING_FIELDS";
+        throw error;
+    }
+    log?.info?.(`[SkillsHandler] Creating skill: ${skillName}`);
+    if (agentIds.length > 0) {
+        log?.info?.(`[SkillsHandler] Target agents: ${agentIds.join(", ")}`);
+    }
+    // 如果提供了 URL，从 URL 下载 skill 定义
+    if (unloadUrl) {
+        log?.info?.(`[SkillsHandler] Downloading skill from URL: ${unloadUrl}`);
+        try {
+            // 下载 skill 定义
+            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 = new Error(`Failed to install skill to agent ${agentId}: ${installResult.message}`);
+                    error.code = "INSTALL_FAILED";
+                    throw error;
+                }
+                installResults.push(installResult);
+            }
+            // 如果没有指定智能体，安装到默认位置
+            if (agentIds.length === 0) {
+                const installResult = await installSkillToClaw(skillName, skillContent, undefined, log);
+                if (!installResult.success) {
+                    const error = new Error(installResult.message);
+                    error.code = "INSTALL_FAILED";
+                    throw error;
+                }
+                installResults.push(installResult);
+            }
+            log?.info?.(`[SkillsHandler] Skill installed to ${installResults.length} locations`);
+            return {
+                userId,
+                skillName,
+                agentId: "",
+                agentIds: agentIds.length > 0 ? agentIds : undefined,
+                status: "add",
+                installedAt: new Date().toISOString(),
+            };
+        }
+        catch (err) {
+            log?.error?.(`[SkillsHandler] Failed to create skill from URL: ${err.message}`);
+            throw err;
+        }
+    }
+    return {
+        userId,
+        skillName,
+        agentId: "",
+        agentIds: agentIds.length > 0 ? agentIds : undefined,
+        status: "add",
+        createdAt: new Date().toISOString(),
+    };
+}
+/**
+ * 更新 Skill
+ */
+async function handleUpdateSkill(data, log) {
+    const { id, ...updates } = data;
+    if (!id) {
+        const error = new Error("Missing required field: id");
+        error.code = "MISSING_FIELDS";
+        throw error;
+    }
+    log?.info?.(`[SkillsHandler] Updating skill: ${id}`);
+    return {
+        id,
+        ...updates,
+        status: "updated",
+        updatedAt: new Date().toISOString(),
+    };
+}
+/**
+ * 删除 Skill
+ */
+async function handleDeleteSkill(data, log) {
+    const { userId, skillName, agentIds } = data;
+    const agentIdsList = Array.isArray(agentIds) ? agentIds : (agentIds ? [agentIds] : []);
+    if (!skillName) {
+        const error = new Error("Missing required field: skillName");
+        error.code = "MISSING_FIELDS";
+        throw error;
+    }
+    log?.info?.(`[SkillsHandler] Deleting skill: ${skillName}`);
+    if (agentIdsList.length > 0) {
+        log?.info?.(`[SkillsHandler] Target agents: ${agentIdsList.join(", ")}`);
+    }
+    try {
+        let deleted = false;
+        // 从多个智能体中删除技能
+        for (const agentId of agentIdsList) {
+            // 获取技能目录
+            const skillsDir = await getSkillsDir(agentId, 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) {
+                // 文件不存在，继续尝试删除目录
+            }
+            // 尝试删除技能目录（ZIP 安装的技能）
+            try {
+                await fs.rm(skillDirPath, { recursive: true, force: true });
+                log?.info?.(`[SkillsHandler] Skill directory deleted: ${skillDirPath}`);
+                deleted = true;
+            }
+            catch (err) {
+                // 目录不存在，继续
+            }
+        }
+        // 如果没有指定智能体，从默认位置删除
+        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) {
+                // 文件不存在，继续尝试删除目录
+            }
+            // 尝试删除技能目录（ZIP 安装的技能）
+            try {
+                await fs.rm(skillDirPath, { recursive: true, force: true });
+                log?.info?.(`[SkillsHandler] Skill directory deleted: ${skillDirPath}`);
+                deleted = true;
+            }
+            catch (err) {
+                // 目录不存在，继续
+            }
+        }
+        if (!deleted) {
+            const error = new Error(`Skill not found: ${skillName}`);
+            error.code = "SKILL_NOT_FOUND";
+            throw error;
+        }
+        return {
+            userId,
+            skillName,
+            agentId: "",
+            agentIds: agentIdsList.length > 0 ? agentIdsList : undefined,
+            status: "remove",
+            deletedAt: new Date().toISOString(),
+        };
+    }
+    catch (err) {
+        log?.error?.(`[SkillsHandler] Failed to delete skill: ${err.message}`);
+        throw err;
+    }
+}
+/**
+ * 查询 Skills 列表
+ */
+async function handleListSkills(data, log) {
+    const { filter, limit = 100 } = data;
+    log?.info?.(`[SkillsHandler] Listing skills, filter: ${filter}, limit: ${limit}`);
+    try {
+        // 调用 openclaw skills list 命令
+        const { stdout } = await execAsync("openclaw skills list --json", {
+            timeout: 10000,
+        });
+        let skills = [];
+        try {
+            const parsed = JSON.parse(stdout);
+            skills = parsed.skills || parsed;
+        }
+        catch {
+            // 解析文本输出
+            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",
+                    };
+                }
+                return null;
+            })
+                .filter((s) => s !== null);
+        }
+        // 应用过滤
+        if (filter) {
+            skills = skills.filter((s) => s.status === filter);
+        }
+        // 应用 limit
+        skills = skills.slice(0, limit);
+        return {
+            total: skills.length,
+            skills,
+        };
+    }
+    catch (err) {
+        log?.error?.(`[SkillsHandler] Failed to list skills: ${err.message}`);
+        // 返回空列表而不是报错
+        return {
+            total: 0,
+            skills: [],
+        };
+    }
+}
+/**
+ * 查询单个 Skill
+ */
+async function handleGetSkill(data, log) {
+    const { id } = data;
+    if (!id) {
+        const error = new Error("Missing required field: id");
+        error.code = "MISSING_FIELDS";
+        throw error;
+    }
+    log?.info?.(`[SkillsHandler] Getting skill: ${id}`);
+    // TODO: 实现实际的 skill 查询逻辑
+    return {
+        id,
+        name: `Skill ${id}`,
+        description: "Skill description",
+        status: "ready",
+    };
+}
+/**
+ * 执行 Skill
+ */
+async function handleInvokeSkill(data, log) {
+    const { id, input, context } = data;
+    if (!id) {
+        const error = new Error("Missing required field: id");
+        error.code = "MISSING_FIELDS";
+        throw error;
+    }
+    log?.info?.(`[SkillsHandler] Invoking skill: ${id}`);
+    // TODO: 实现实际的 skill 执行逻辑
+    return {
+        id,
+        status: "completed",
+        output: {
+            result: `Skill ${id} executed successfully`,
+            input,
+            context,
+        },
+        executedAt: new Date().toISOString(),
+    };
+}

package/dist/src/gateway/skills-list-handler.d.ts

@@ -0,0 +1,27 @@
+export interface SkillsListEvent {
+    agentId: string | number;
+    userId: string | number;
+}
+export interface SkillItem {
+    typeStr: string;
+    name: string;
+    description: string;
+}
+export interface SkillsListCallbackPayload {
+    userId: number;
+    agentId: number;
+    dataList: SkillItem[];
+}
+/**
+ * 处理 SKILLS_LIST 事件
+ * @param event - 事件数据
+ * @param baseUrl - 回调基础 URL
+ * @param token - 鉴权 token
+ * @param log 日志对象（可选）
+ * @param {Function} [log.info] - 信息日志函数
+ * @param {Function} [log.error] - 错误日志函数
+ */
+export declare function handleSkillsListEvent(event: SkillsListEvent, baseUrl: string, token: string, log?: {
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
+}): Promise<void>;