@workclaw/openclaw-workclaw 1.0.201 → 1.0.331

package/dist/packages/plugin/src/gateway/reconnect.js

@@ -0,0 +1,178 @@
+import { Agent, WebSocket } from "undici";
+import { clearWorkclawTokenCache, openWorkclawConnection } from "../connection/workclaw-client.js";
+import logger from "../logging.js";
+import { setWorkclawWsConnection, clearWorkclawWsConnection } from "../../../../src/runtime.js";
+function createReconnectScheduler(options) {
+  const { key, config, onMessage, onReconnectSuccess, onClose, onConnectingStarted } = options;
+  let reconnectBackoff = 5e3;
+  let shouldStopReconnect = false;
+  let pendingReconnectTimer = null;
+  let pendingDoConnectPromise = null;
+  async function doConnect() {
+    if (pendingDoConnectPromise !== null) {
+      return pendingDoConnectPromise;
+    }
+    let resolveThis;
+    let rejectThis;
+    const p = new Promise((resolve, reject) => {
+      resolveThis = resolve;
+      rejectThis = reject;
+    });
+    pendingDoConnectPromise = p;
+    const tokenCacheKey = config.appKey || key;
+    clearWorkclawTokenCache(tokenCacheKey);
+    const connConfig = {
+      baseUrl: config.baseUrl || "",
+      websocketUrl: config.websocketUrl,
+      appKey: config.appKey,
+      appSecret: config.appSecret,
+      localIp: config.localIp,
+      allowInsecureTls: config.allowInsecureTls,
+      requestTimeout: config.requestTimeout
+    };
+    let endpoint;
+    let ticket;
+    try {
+      const result = await openWorkclawConnection(tokenCacheKey, connConfig);
+      endpoint = result.endpoint;
+      ticket = result.ticket;
+    } catch (err) {
+      const willRetry = handleConnectError(String(err));
+      if (!willRetry) {
+        pendingDoConnectPromise = null;
+        rejectThis(err);
+      }
+      throw err;
+    }
+    const url = `${endpoint}?ticket=${encodeURIComponent(ticket)}`;
+    const dispatcher = connConfig.allowInsecureTls ? new Agent({ connect: { rejectUnauthorized: false } }) : void 0;
+    const wsOptions = dispatcher ? { dispatcher } : void 0;
+    const ws = new WebSocket(url, wsOptions);
+    setWorkclawWsConnection(key, ws);
+    onConnectingStarted?.(ws);
+    ws.onopen = () => {
+      logger.info(`网关 WebSocket 已连接 endpoint=${endpoint}`);
+      reconnectBackoff = 5e3;
+      onReconnectSuccess?.();
+      resolveThis();
+    };
+    ws.onerror = (event) => {
+      logger.error(`网关 WebSocket 错误: ${String(event?.message ?? event)}`);
+      rejectThis(new Error(String(event?.message ?? event)));
+    };
+    ws.onclose = (event) => {
+      const code = String(event?.code ?? "");
+      const reason = String(event?.reason ?? "");
+      logger.warn(`网关 WebSocket 关闭 code=${code} reason=${reason}`);
+      clearWorkclawWsConnection(key);
+      if (onClose) {
+        onClose();
+      } else {
+        scheduleReconnect();
+      }
+      rejectThis(new Error(`WebSocket 关闭 code=${code} reason=${reason}`));
+    };
+    ws.onmessage = (event) => {
+      const data = typeof event.data === "string" ? event.data : String(event.data ?? "");
+      logger.info(`网关 WebSocket 收到消息 bytes=${data.length}`);
+      onMessage(data);
+    };
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error("websocket 连接超时")), 3e4);
+      ws.addEventListener("open", () => {
+        clearTimeout(timeout);
+        resolve();
+      }, { once: true });
+      ws.addEventListener("error", (event) => {
+        clearTimeout(timeout);
+        reject(new Error(String(event?.message ?? event)));
+      }, { once: true });
+      ws.addEventListener("close", (event) => {
+        clearTimeout(timeout);
+        reject(new Error(`websocket 在就绪前关闭 code=${event?.code ?? ""} reason=${event?.reason ?? ""}`));
+      }, { once: true });
+    });
+  }
+  const scheduleReconnect = () => {
+    if (shouldStopReconnect) {
+      logger.info(`重连: 由于之前的认证失败而停止`);
+      return;
+    }
+    if (pendingReconnectTimer !== null) {
+      logger.info(`重连: 已经计划，跳过重复`);
+      return;
+    }
+    const jitter = Math.floor(Math.random() * 3e3);
+    const delayMs = reconnectBackoff + jitter;
+    logger.info(`重连: 在 ${delayMs}ms 后计划 (base=${reconnectBackoff} + jitter=${jitter}) key=${key}`);
+    pendingReconnectTimer = setTimeout(async () => {
+      pendingReconnectTimer = null;
+      pendingDoConnectPromise = null;
+      try {
+        logger.info(`重连: 尝试连接... key=${key}`);
+        await doConnect();
+        logger.info(`重连: 成功`);
+      } catch (err) {
+        const errorStr = String(err);
+        logger.error(`重连: 失败: ${errorStr}`);
+        const willRetry = handleConnectError(errorStr);
+        if (!willRetry) {
+          pendingDoConnectPromise = null;
+        } else {
+          scheduleReconnect();
+        }
+      }
+    }, delayMs);
+  };
+  function handleConnectError(errorStr) {
+    if (errorStr.includes("访问过于频繁")) {
+      logger.warn(`重连: 频率限制，使用最小退避重试`);
+      if (pendingReconnectTimer !== null) {
+        clearTimeout(pendingReconnectTimer);
+        pendingReconnectTimer = null;
+      }
+      reconnectBackoff = 1e3;
+      scheduleReconnect();
+      return true;
+    }
+    const isAuthError = errorStr.includes('"errCode":2001') || errorStr.includes('"code":2001') || errorStr.includes("鉴权失败") || errorStr.includes("invalid credentials") || errorStr.includes("unauthorized");
+    if (isAuthError) {
+      logger.error(`重连: 认证失败，停止`);
+      shouldStopReconnect = true;
+      if (pendingReconnectTimer !== null) {
+        clearTimeout(pendingReconnectTimer);
+        pendingReconnectTimer = null;
+      }
+      return false;
+    }
+    return true;
+  }
+  async function connect() {
+    if (pendingDoConnectPromise !== null) {
+      return pendingDoConnectPromise;
+    }
+    try {
+      return await doConnect();
+    } catch (err) {
+      const errorStr = String(err);
+      logger.error(`网关连接失败: ${errorStr}`);
+      const willRetry = handleConnectError(errorStr);
+      if (!willRetry) {
+        pendingDoConnectPromise = null;
+        throw err;
+      }
+      scheduleReconnect();
+    }
+  }
+  const stopReconnect = () => {
+    shouldStopReconnect = true;
+    if (pendingReconnectTimer !== null) {
+      clearTimeout(pendingReconnectTimer);
+      pendingReconnectTimer = null;
+    }
+  };
+  return { connect, scheduleReconnect, stopReconnect };
+}
+export {
+  createReconnectScheduler
+};

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

@@ -0,0 +1,511 @@
+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$1 from "node:process";
+import { promisify } from "node:util";
+import logger from "../logging.js";
+const execAsync = promisify(exec);
+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"
+};
+async function handleSkillsEvent(eventData, token, baseUrl, appKey, log) {
+  const { topic, data } = eventData;
+  logger.info(`[智小途-技能] 处理 ${topic}，数据: ${JSON.stringify(data)}`);
+  try {
+    let result;
+    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
+    );
+    logger.info(`[技能处理器] ${topic} 完成，回调已发送`);
+    if (["skills/add", "skills/update", "skills/remove"].includes(topic)) {
+      try {
+        logger.info(`[智小途-技能] 重新扫描中...`);
+        await execAsync(`openclaw skills rescan`, { timeout: 2e3 });
+        await execAsync(`openclaw skills reload --force`, { timeout: 2e3 });
+        await execAsync(`openclaw skills list`, { timeout: 2e3 });
+        logger.info(`[智小途-技能] OpenClaw 技能重新扫描成功`);
+      } catch (err) {
+        logger.error(`[智小途-技能] 重新扫描 OpenClaw 技能失败: ${err.message}`);
+        await execAsync(`openclaw skills restart`, { timeout: 2e4 });
+      }
+    }
+  } catch (err) {
+    logger.error(`[智小途-技能] ${topic} 失败: ${err.message}`);
+    await sendCallback(
+      baseUrl,
+      topic,
+      {
+        userId: "",
+        agentId: "",
+        agentIds: [],
+        appKey,
+        dotype: topic.split("/")[1],
+        doStatus: false,
+        doErrorMsg: err.message,
+        dataList: [
+          {
+            typeStr: "",
+            name: "",
+            description: ""
+          }
+        ]
+      },
+      token
+    );
+  }
+}
+async function sendCallback(baseUrl, topic, response, authToken, log) {
+  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);
+  logger.info(`[智小途-技能] 发送回调到 ${callbackUrl}，数据: ${responseData}`);
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (authToken) {
+    headers.Authorization = authToken.startsWith("Bearer ") ? authToken : `Bearer ${authToken}`;
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 3e4);
+  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}`);
+    }
+    logger.info(`[技能处理器] 回调发送成功，状态: ${res.status}`);
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (err.name === "AbortError") {
+      logger.error(`[技能处理器] 回调超时 30 秒: ${callbackUrl}`);
+      throw new Error("Callback timeout");
+    }
+    logger.error(`[技能处理器] 发送回调失败: ${err.message}`);
+    throw err;
+  }
+}
+async function downloadFromUrl(url) {
+  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(3e4, () => {
+      req.destroy();
+      reject(new Error("Download timeout"));
+    });
+  });
+}
+function getOpenClawConfigDir() {
+  const homeDir = os.homedir();
+  return path.join(homeDir, ".openclaw");
+}
+async function getSkillsDir(agentId, log) {
+  const openclawDir = getOpenClawConfigDir();
+  let skillsDir = path.join(openclawDir, "workspace", "skills");
+  if (agentId && agentId.trim()) {
+    skillsDir = path.join(openclawDir, `workspace-${agentId}`, "skills");
+  }
+  try {
+    await fs.mkdir(skillsDir, { recursive: true });
+  } catch (err) {
+    logger.error(`[智小途-技能] 创建技能目录失败: ${err.message}`);
+    throw new Error(`Failed to create skills directory: ${err.message}`);
+  }
+  return skillsDir;
+}
+async function installSkillToClaw(skillName, skillContent, agentId, log) {
+  try {
+    const isZip = skillContent.toString("utf8", 0, 2) === "PK";
+    if (isZip) {
+      logger.info(`[技能处理器] 检测到 ZIP 文件，正在解压...`);
+      const skillsDir2 = await getSkillsDir(agentId, log);
+      const skillDir = path.join(skillsDir2, skillName);
+      const tempZipPath = path.join(skillsDir2, `${skillName}.zip`);
+      try {
+        await fs.mkdir(skillDir, { recursive: true });
+        logger.info(`[智小途-技能] 技能目录已创建: ${skillDir}`);
+        await fs.writeFile(tempZipPath, skillContent);
+        logger.info(`[智小途-技能] 临时 ZIP 文件已创建: ${tempZipPath}`);
+        if (process$1.platform === "win32") {
+          await execAsync(`powershell -Command "Expand-Archive -Path '${tempZipPath}' -DestinationPath '${skillDir}' -Force"`);
+        } else {
+          await execAsync(`unzip -o '${tempZipPath}' -d '${skillDir}'`);
+        }
+        logger.info(`[技能处理器] ZIP 文件成功解压到: ${skillDir}`);
+        await fs.unlink(tempZipPath);
+        logger.info(`[技能处理器] 临时 ZIP 文件已删除`);
+        return {
+          success: true,
+          message: `ZIP skill package ${skillName} installed successfully`,
+          path: skillDir
+        };
+      } catch (err) {
+        logger.error(`[智小途-技能] 解压 ZIP 文件失败: ${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}`
+        };
+      }
+    }
+    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"
+      };
+    }
+    const skillsDir = await getSkillsDir(agentId, log);
+    const skillFilePath = path.join(skillsDir, `${skillName}.json`);
+    await fs.writeFile(skillFilePath, skillContent, "utf-8");
+    logger.info(`[技能处理器] 技能已保存到: ${skillFilePath}`);
+    return {
+      success: true,
+      message: `Skill ${skillName} installed successfully`,
+      path: skillFilePath
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Failed to install skill: ${err.message}`
+    };
+  }
+}
+async function installSkillToLocations(skillName, skillContent, locations, log) {
+  const installResults = [];
+  for (const agentId of locations) {
+    const installResult = await installSkillToClaw(skillName, skillContent, agentId, log);
+    if (!installResult.success) {
+      const error = 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, log) {
+  const { userId, skillName, unloadUrl, mainId } = 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;
+  }
+  logger.info(`[技能处理器] 创建技能: ${skillName}`);
+  logger.info(`[技能处理器] mainId: ${mainId}`);
+  if (agentIds.length > 0) {
+    logger.info(`[技能处理器] 目标智能体: ${agentIds.join(", ")}`);
+  }
+  if (unloadUrl) {
+    logger.info(`[技能处理器] 从 URL 下载技能: ${unloadUrl}`);
+    try {
+      const skillContent = await downloadFromUrl(unloadUrl);
+      logger.info(`[技能处理器] 已下载技能内容，大小: ${skillContent.length} 字节`);
+      const installLocations = [];
+      const hasOnlyMainId = agentIds.length === 1 && agentIds[0] === mainId;
+      const hasMainIdAndOthers = agentIds.includes(mainId) && agentIds.length > 1;
+      if (hasOnlyMainId) {
+        logger.info(`[智小途-技能] 仅有 mainId，安装到默认位置`);
+        installLocations.push(void 0);
+      } else if (hasMainIdAndOthers) {
+        logger.info(`[智小途-技能] 有 mainId 和其他智能体，安装到默认位置和其他智能体`);
+        installLocations.push(void 0);
+        installLocations.push(...agentIds.filter((id) => id !== mainId));
+      } else if (agentIds.length > 0) {
+        logger.info(`[智小途-技能] 没有 mainId，安装到所有指定的智能体`);
+        installLocations.push(...agentIds);
+      } else {
+        logger.info(`[智小途-技能] 没有指定智能体，安装到默认位置`);
+        installLocations.push(void 0);
+      }
+      const installResults = await installSkillToLocations(skillName, skillContent, installLocations, log);
+      logger.info(`[智小途-技能] 技能已安装到 ${installResults.length} 个位置`);
+      return {
+        userId,
+        skillName,
+        agentId: "",
+        agentIds: agentIds.length > 0 ? agentIds : void 0,
+        status: "add",
+        installedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    } catch (err) {
+      logger.error(`[智小途-技能] 从 URL 创建技能失败: ${err.message}`);
+      throw err;
+    }
+  }
+  return {
+    userId,
+    skillName,
+    agentId: "",
+    agentIds: agentIds.length > 0 ? agentIds : void 0,
+    status: "add",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+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;
+  }
+  logger.info(`[智小途-技能] 更新技能: ${id}`);
+  return {
+    id,
+    ...updates,
+    status: "updated",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function deleteSkillAtLocation(skillName, agentId, log) {
+  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);
+      logger.info(`[智小途-技能] 技能文件已删除: ${skillFilePath}`);
+      deleted = true;
+    } catch {
+    }
+    try {
+      await fs.rm(skillDirPath, { recursive: true, force: true });
+      logger.info(`[智小途-技能] 技能目录已删除: ${skillDirPath}`);
+      deleted = true;
+    } catch {
+    }
+    return deleted;
+  } catch (err) {
+    logger.error(`[智小途-技能] 删除技能失败: ${err.message}`);
+    return false;
+  }
+}
+async function handleDeleteSkill(data, log) {
+  const { userId, skillName, agentIds, mainId } = 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;
+  }
+  logger.info(`[智小途-技能] 删除技能: ${skillName}`);
+  logger.info(`[智小途-技能] mainId: ${mainId}`);
+  if (agentIdsList.length > 0) {
+    logger.info(`[智小途-技能] 目标智能体: ${agentIdsList.join(", ")}`);
+  }
+  try {
+    let deleted = false;
+    const hasOnlyMainId = agentIdsList.length === 1 && agentIdsList[0] === mainId;
+    const hasMainIdAndOthers = agentIdsList.includes(mainId) && agentIdsList.length > 1;
+    if (hasOnlyMainId) {
+      logger.info(`[智小途-技能] 仅有 mainId，从默认位置删除`);
+      deleted = await deleteSkillAtLocation(skillName, void 0, log);
+    } else if (hasMainIdAndOthers) {
+      logger.info(`[智小途-技能] 有 mainId 和其他智能体，从默认位置和其他智能体删除`);
+      const defaultDeleted = await deleteSkillAtLocation(skillName, void 0, log);
+      deleted = deleted || defaultDeleted;
+      for (const agentId of agentIdsList) {
+        if (agentId !== mainId) {
+          const agentDeleted = await deleteSkillAtLocation(skillName, agentId, log);
+          deleted = deleted || agentDeleted;
+        }
+      }
+    } else if (agentIdsList.length > 0) {
+      logger.info(`[智小途-技能] 没有 mainId，从所有指定的智能体删除`);
+      for (const agentId of agentIdsList) {
+        const agentDeleted = await deleteSkillAtLocation(skillName, agentId, log);
+        deleted = deleted || agentDeleted;
+      }
+    } else {
+      logger.info(`[智小途-技能] 没有指定智能体，从默认位置删除`);
+      deleted = await deleteSkillAtLocation(skillName, void 0, log);
+    }
+    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 : void 0,
+      status: "remove",
+      deletedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (err) {
+    logger.error(`[技能处理器] 删除技能失败: ${err.message}`);
+    throw err;
+  }
+}
+async function handleListSkills(data, log) {
+  const { filter, limit = 100 } = data;
+  logger.info(`[技能处理器] 列出技能，过滤: ${filter}，限制: ${limit}`);
+  try {
+    const { stdout } = await execAsync("openclaw skills list --json", {
+      timeout: 1e4
+    });
+    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);
+    }
+    skills = skills.slice(0, limit);
+    return {
+      total: skills.length,
+      skills
+    };
+  } catch (err) {
+    logger.error(`[技能处理器] 列出技能失败: ${err.message}`);
+    return {
+      total: 0,
+      skills: []
+    };
+  }
+}
+async function handleGetSkill(data, log) {
+  const { id } = data;
+  if (!id) {
+    const error = new Error("Missing required field: id");
+    error.code = "MISSING_FIELDS";
+    throw error;
+  }
+  logger.info(`[智小途-技能] 获取技能: ${id}`);
+  return {
+    id,
+    name: `Skill ${id}`,
+    description: "Skill description",
+    status: "ready"
+  };
+}
+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;
+  }
+  logger.info(`[技能处理器] 调用技能: ${id}`);
+  return {
+    id,
+    status: "completed",
+    output: {
+      result: `Skill ${id} executed successfully`,
+      input,
+      context
+    },
+    executedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+export {
+  handleSkillsEvent
+};