@workclaw/openclaw-workclaw 1.0.17 → 1.0.18

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

@@ -4,6 +4,11 @@
  */
 import { readFileSync } from 'node:fs'
 
+import { execSync } from "child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readdirSync, statSync } from "node:fs";
+
 export interface SkillsListEvent {
   agentId: string | number
   userId: string | number
@@ -83,10 +88,8 @@ async function fetchSkillsFromOpenClaw(
 
   try {
     // 使用 OpenClaw CLI 获取 skills 列表（全局技能）
-    const { execSync } = await import('node:child_process')
-
-    const result = execSync('openclaw skills list', {
-      encoding: 'utf-8',
+    const result = execSync("openclaw skills list", {
+      encoding: "utf-8",
       timeout: 30000, // 30秒超时
     })
 
@@ -123,13 +126,10 @@ async function fetchAgentWorkspaceSkills(
 
   try {
     // 智能体工作区路径
-    const { homedir } = await import('node:os')
-    const { join } = await import('node:path')
-    const agentWorkspace = join(homedir(), '.openclaw', 'agents', `openclaw-workclaw-${agentId}`)
-    const skillsDir = join(agentWorkspace, 'skills')
+    const agentWorkspace = join(homedir(), ".openclaw", "agents", `openclaw-workclaw-${agentId}`);
+    const skillsDir = join(agentWorkspace, "skills");
 
     // 检查技能目录是否存在
-    const { existsSync, readdirSync, statSync } = await import('node:fs')
     if (!existsSync(skillsDir)) {
       log?.info?.(`SkillsList: No skills directory found in agent workspace: ${skillsDir}`)
       return skills

package/src/gateway/tools-list-handler.ts

@@ -4,66 +4,68 @@
  * 从 OpenClaw 获取 tools 列表并通过 HTTP 回调返回
  */
 
-import { fetch } from 'undici'
+import { fetch } from "undici";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
 
 export interface ToolsListEvent {
-  agentId: string | number
-  userId: string | number
+  agentId: string | number;
+  userId: string | number;
 }
 
 export interface ToolItem {
-  typeStr: string
-  name: string
-  description: string
+  typeStr: string;
+  name: string;
+  description: string;
 }
 
 export interface ToolsListCallbackPayload {
-  userId: number
-  agentId: number
-  dataList: ToolItem[]
+  userId: number;
+  agentId: number;
+  dataList: ToolItem[];
 }
 
 /**
  * 处理 TOOLS_LIST 事件
- * @param event - 事件数据
- * @param baseUrl - 回调基础 URL
- * @param token - 鉴权 token
- * @param log - 日志对象（可选）
+ * @param event 事件数据
+ * @param baseUrl 回调基础 URL
+ * @param token 鉴权 token
+ * @param log 日志函数
  */
 export async function handleToolsListEvent(
   event: ToolsListEvent,
   baseUrl: string,
   token: string,
   log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
   },
 ): Promise<void> {
-  const agentId = Number(event.agentId)
-  const userId = Number(event.userId)
+  const agentId = Number(event.agentId);
+  const userId = Number(event.userId);
 
-  log?.info?.(`ToolsList: Handling TOOLS_LIST event for agentId: ${agentId}, userId: ${userId}`)
+  log?.info?.(`ToolsList: Handling TOOLS_LIST event for agentId: ${agentId}, userId: ${userId}`);
 
   try {
     // 从 OpenClaw 获取 tools 列表
-    const tools = await fetchToolsFromOpenClaw(agentId, userId, log)
+    const tools = await fetchToolsFromOpenClaw(agentId, userId, log);
 
     // 构建回调 payload
     const callbackPayload: ToolsListCallbackPayload = {
       userId,
       agentId,
       dataList: tools,
-    }
+    };
 
     // 发送回调
-    const callbackUrl = `${baseUrl.replace(/\/$/, '')}/open-apis/v1/claw/push/tools`
-    await sendToolsListCallback(callbackUrl, callbackPayload, token, log)
+    const callbackUrl = `${baseUrl.replace(/\/$/, "")}/open-apis/v1/claw/push/tools`;
+    await sendToolsListCallback(callbackUrl, callbackPayload, token, log);
 
-    log?.info?.(`ToolsList: Successfully processed TOOLS_LIST event, sent ${tools.length} tools`)
-  }
-  catch (error) {
-    log?.error?.(`ToolsList: Failed to handle TOOLS_LIST event: ${String(error)}`)
-    throw error
+    log?.info?.(`ToolsList: Successfully processed TOOLS_LIST event, sent ${tools.length} tools`);
+  } catch (error) {
+    log?.error?.(`ToolsList: Failed to handle TOOLS_LIST event: ${String(error)}`);
+    throw error;
   }
 }
 
@@ -73,60 +75,56 @@ export async function handleToolsListEvent(
  */
 async function fetchToolsFromOpenClaw(
   agentId: number,
-  _userId: number,
+  userId: number,
   log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
   },
 ): Promise<ToolItem[]> {
-  log?.info?.(`ToolsList: Fetching tools from OpenClaw for agentId: ${agentId}`)
+  log?.info?.(`ToolsList: Fetching tools from OpenClaw for agentId: ${agentId}`);
 
   // OpenClaw 所有内置工具列表
   const allTools: ToolItem[] = [
-    { typeStr: 'function', name: 'web_search', description: 'Search the web for information using Brave Search API.' },
-    { typeStr: 'function', name: 'web_fetch', description: 'Fetch and read content from a URL.' },
-    { typeStr: 'function', name: 'sessions_list', description: 'List all active agent sessions.' },
-    { typeStr: 'function', name: 'sessions_history', description: 'Get the history of a specific session.' },
-    { typeStr: 'function', name: 'memory_search', description: 'Search memory for past conversations and information.' },
-    { typeStr: 'function', name: 'memory_get', description: 'Get specific memory by ID.' },
-    { typeStr: 'function', name: 'gateway', description: 'Gateway control operations.' },
-    { typeStr: 'function', name: 'exec', description: 'Execute shell commands.' },
-  ]
+    { typeStr: "function", name: "web_search", description: "Search the web for information using Brave Search API." },
+    { typeStr: "function", name: "web_fetch", description: "Fetch and read content from a URL." },
+    { typeStr: "function", name: "sessions_list", description: "List all active agent sessions." },
+    { typeStr: "function", name: "sessions_history", description: "Get the history of a specific session." },
+    { typeStr: "function", name: "memory_search", description: "Search memory for past conversations and information." },
+    { typeStr: "function", name: "memory_get", description: "Get specific memory by ID." },
+    { typeStr: "function", name: "gateway", description: "Gateway control operations." },
+    { typeStr: "function", name: "exec", description: "Execute shell commands." },
+  ];
 
   try {
     // 读取 OpenClaw 配置文件
-    const { readFile } = await import('node:fs/promises')
-    const { homedir } = await import('node:os')
-    const path = await import('node:path')
-
-    const configPath = path.join(homedir(), '.openclaw', 'openclaw.json')
-    const configContent = await readFile(configPath, 'utf-8')
-    const config = JSON.parse(configContent)
+    const configPath = path.join(homedir(), ".openclaw", "openclaw.json");
+    const configContent = await readFile(configPath, "utf-8");
+    const config = JSON.parse(configContent);
 
     // 查找对应的 agent 配置
-    const agentConfig = config.agents?.list?.find((agent: any) =>
-      String(agent.id) === String(agentId)
-      || agent.id === `openclaw-workclaw-${agentId}`,
-    )
+    const agentConfig = config.agents?.list?.find((agent: any) => 
+      String(agent.id) === String(agentId) || 
+      agent.id === `openclaw-workclaw-${agentId}`
+    );
 
     // 获取 tools.allow 配置
-    const allowTools = agentConfig?.tools?.allow
+    const allowTools = agentConfig?.tools?.allow;
 
     // 如果没有 allow 配置，或者 allow 是 ["*"]，返回所有工具
-    if (!allowTools || allowTools.length === 0 || allowTools.includes('*')) {
-      log?.info?.(`ToolsList: Agent has no allow restriction or allow=[*], returning all ${allTools.length} tools`)
-      return allTools
+    if (!allowTools || allowTools.length === 0 || allowTools.includes("*")) {
+      log?.info?.(`ToolsList: Agent has no allow restriction or allow=[*], returning all ${allTools.length} tools`);
+      return allTools;
     }
 
     // 如果有具体的 allow 列表，只返回列表中的工具
-    const filteredTools = allTools.filter(tool => allowTools.includes(tool.name))
-    log?.info?.(`ToolsList: Agent allow=${JSON.stringify(allowTools)}, returning ${filteredTools.length} tools`)
-    return filteredTools
-  }
-  catch (error) {
-    log?.error?.(`ToolsList: Error reading agent config: ${String(error)}, returning all tools`)
+    const filteredTools = allTools.filter(tool => allowTools.includes(tool.name));
+    log?.info?.(`ToolsList: Agent allow=${JSON.stringify(allowTools)}, returning ${filteredTools.length} tools`);
+    return filteredTools;
+
+  } catch (error) {
+    log?.error?.(`ToolsList: Error reading agent config: ${String(error)}, returning all tools`);
     // 如果读取配置失败，返回所有工具
-    return allTools
+    return allTools;
   }
 }
 
@@ -138,25 +136,25 @@ async function sendToolsListCallback(
   payload: ToolsListCallbackPayload,
   token: string,
   log?: {
-    info?: (msg: string) => void
-    error?: (msg: string) => void
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
   },
 ): Promise<void> {
-  log?.info?.(`ToolsList: Sending callback to ${callbackUrl}`)
+  log?.info?.(`ToolsList: Sending callback to ${callbackUrl}`);
 
   const response = await fetch(callbackUrl, {
-    method: 'POST',
+    method: "POST",
     headers: {
-      'Content-Type': 'application/json',
-      'Authorization': `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`,
     },
     body: JSON.stringify(payload),
-  })
+  });
 
   if (!response.ok) {
-    const errorText = await response.text()
-    throw new Error(`Callback failed: ${response.status} ${response.statusText} - ${errorText}`)
+    const errorText = await response.text();
+    throw new Error(`Callback failed: ${response.status} ${response.statusText} - ${errorText}`);
   }
 
-  log?.info?.(`ToolsList: Callback sent successfully: ${response.status}`)
+  log?.info?.(`ToolsList: Callback sent successfully: ${response.status}`);
 }