@workclaw/openclaw-workclaw 1.0.0

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

@@ -0,0 +1,332 @@
+/**
+ * Skills list handler - 处理 SKILLS_LIST 事件
+ * 从 OpenClaw 获取 skills 列表并通过回调返回
+ */
+import { readFileSync } from 'node:fs'
+
+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 async function handleSkillsListEvent(
+  event: SkillsListEvent,
+  baseUrl: string,
+  token: string,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): Promise<void> {
+  const agentId = Number(event.agentId)
+  const userId = Number(event.userId)
+
+  log?.info?.(`SkillsList: Handling SKILLS_LIST event for agentId: ${agentId}, userId: ${userId}`)
+
+  try {
+    // 从 OpenClaw 获取 skills 列表
+    const skills = await fetchSkillsFromOpenClaw(agentId, userId, log)
+
+    // 构建回调 payload
+    const callbackPayload: SkillsListCallbackPayload = {
+      userId,
+      agentId,
+      dataList: skills,
+    }
+
+    // 发送回调
+    const callbackUrl = `${baseUrl.replace(/\/$/, '')}/open-apis/v1/claw/push/skills`
+    await sendSkillsListCallback(callbackUrl, callbackPayload, token, log)
+
+    log?.info?.(`SkillsList: Successfully processed SKILLS_LIST event, sent ${skills.length} skills`)
+  }
+  catch (error) {
+    log?.error?.(`SkillsList: Failed to handle SKILLS_LIST event: ${String(error)}`)
+    throw error
+  }
+}
+
+/**
+ * 从 OpenClaw 获取 skills 列表
+ * 包括全局技能和智能体工作区的专有技能
+ */
+async function fetchSkillsFromOpenClaw(
+  agentId: number,
+  _userId: number,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): Promise<SkillItem[]> {
+  log?.info?.(`SkillsList: Fetching skills from OpenClaw for agentId: ${agentId}`)
+
+  try {
+    // 使用 OpenClaw CLI 获取 skills 列表（全局技能）
+    const { execSync } = await import('node:child_process')
+
+    const result = execSync('openclaw skills list', {
+      encoding: 'utf-8',
+      timeout: 30000, // 30秒超时
+    })
+
+    // 解析输出
+    const globalSkills = parseSkillsListOutput(result)
+
+    // 检查智能体工作区中的专有技能
+    const agentWorkspaceSkills = await fetchAgentWorkspaceSkills(agentId, log)
+
+    // 合并技能列表，去重
+    const allSkills = mergeSkills(globalSkills, agentWorkspaceSkills)
+
+    log?.info?.(`SkillsList: Found ${allSkills.length} skills (${globalSkills.length} global, ${agentWorkspaceSkills.length} agent-specific)`)
+    return allSkills
+  }
+  catch (error) {
+    log?.error?.(`SkillsList: Error fetching skills: ${String(error)}`)
+    // 如果获取失败，返回空列表
+    return []
+  }
+}
+
+/**
+ * 获取智能体工作区中的专有技能
+ */
+async function fetchAgentWorkspaceSkills(
+  agentId: number,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): Promise<SkillItem[]> {
+  const skills: SkillItem[] = []
+
+  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 { existsSync, readdirSync, statSync } = await import('node:fs')
+    if (!existsSync(skillsDir)) {
+      log?.info?.(`SkillsList: No skills directory found in agent workspace: ${skillsDir}`)
+      return skills
+    }
+
+    // 读取技能目录中的子目录（每个子目录是一个技能）
+    const items = readdirSync(skillsDir)
+    for (const item of items) {
+      const itemPath = join(skillsDir, item)
+      const stat = statSync(itemPath)
+
+      // 如果是目录，检查里面的技能文件
+      if (stat.isDirectory()) {
+        const skillFiles = readdirSync(itemPath)
+        for (const skillFile of skillFiles) {
+          if (skillFile.endsWith('.md') || skillFile.endsWith('.prose')) {
+            const skillFilePath = join(itemPath, skillFile)
+            const skill = parseSkillFile(skillFilePath, item, log)
+            if (skill) {
+              skills.push(skill)
+            }
+          }
+        }
+      }
+    }
+
+    log?.info?.(`SkillsList: Found ${skills.length} agent-specific skills in ${skillsDir}`)
+  }
+  catch (error) {
+    log?.error?.(`SkillsList: Error reading agent workspace skills: ${String(error)}`)
+  }
+
+  return skills
+}
+
+/**
+ * 解析技能文件
+ */
+function parseSkillFile(
+  filePath: string,
+  skillName: string,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): SkillItem | null {
+  try {
+    const content = readFileSync(filePath, 'utf-8')
+
+    // 提取描述（从文件内容中）
+    let description = 'Agent-specific skill'
+    const lines = content.split('\n')
+    for (const line of lines) {
+      if (line.startsWith('# ')) {
+        description = line.substring(2).trim()
+        break
+      }
+      else if (line.startsWith('summary:') || line.startsWith('Summary:')) {
+        description = line.substring(line.indexOf(':') + 1).trim()
+        break
+      }
+    }
+
+    return {
+      typeStr: 'skill',
+      name: skillName,
+      description,
+    }
+  }
+  catch (error) {
+    log?.error?.(`SkillsList: Error parsing skill file ${filePath}: ${String(error)}`)
+    return null
+  }
+}
+
+/**
+ * 合并技能列表，去重
+ */
+function mergeSkills(globalSkills: SkillItem[], agentSkills: SkillItem[]): SkillItem[] {
+  const skillMap = new Map<string, SkillItem>()
+
+  // 先添加全局技能
+  for (const skill of globalSkills) {
+    skillMap.set(skill.name, skill)
+  }
+
+  // 再添加智能体专有技能（会覆盖同名的全局技能）
+  for (const skill of agentSkills) {
+    skillMap.set(skill.name, skill)
+  }
+
+  return Array.from(skillMap.values())
+}
+
+/**
+ * 解析 openclaw skills list 的输出
+ */
+function parseSkillsListOutput(output: string): SkillItem[] {
+  const skills: SkillItem[] = []
+  const lines = output.split('\n')
+
+  // 查找表格内容（从表头后开始）
+  let inTable = false
+  let headerLine = -1
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+
+    // 找到表头行（包含 Status | Skill | Description | Source）
+    if (line.includes('Status') && line.includes('Skill') && line.includes('Description')) {
+      headerLine = i
+      inTable = true
+      continue
+    }
+
+    // 跳过分隔线
+    if (inTable && (line.startsWith('├') || line.startsWith('┌') || line.startsWith('└'))) {
+      continue
+    }
+
+    // 解析表格行
+    if (inTable && line.startsWith('│') && i > headerLine + 1) {
+      const parsed = parseSkillsTableRow(line)
+      if (parsed) {
+        skills.push(parsed)
+      }
+    }
+
+    // 表格结束
+    if (inTable && line.startsWith('└')) {
+      break
+    }
+  }
+
+  return skills
+}
+
+/**
+ * 解析单行表格数据
+ */
+function parseSkillsTableRow(line: string): SkillItem | null {
+  // 移除开头的 │ 和结尾的 │
+  const content = line.replace(/^│\s*/, '').replace(/\s*│$/, '')
+
+  // 按 │ 分割列
+  const columns = content.split('│').map(col => col.trim())
+
+  if (columns.length < 4) {
+    return null
+  }
+
+  const status = columns[0]
+  const skillName = columns[1]
+  const description = columns[2]
+
+  // 只返回 ready 状态的 skills
+  if (!status.includes('✓') && !status.includes('ready')) {
+    return null
+  }
+
+  // 提取 skill 名称（移除 emoji）
+  const cleanName = skillName.replace(/[\u{1F300}-\u{1F9FF}]/gu, '').trim()
+
+  return {
+    typeStr: 'skill',
+    name: cleanName,
+    description,
+  }
+}
+
+/**
+ * 发送 skills 列表回调
+ */
+async function sendSkillsListCallback(
+  callbackUrl: string,
+  payload: SkillsListCallbackPayload,
+  token: string,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): Promise<void> {
+  log?.info?.(`SkillsList: Sending callback to ${callbackUrl}`)
+
+  const response = await fetch(callbackUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`,
+    },
+    body: JSON.stringify(payload),
+  })
+
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => 'Unknown error')
+    throw new Error(`Callback failed: ${response.status} ${errorText}`)
+  }
+
+  log?.info?.(`SkillsList: Callback sent successfully`)
+}

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

@@ -0,0 +1,162 @@
+/**
+ * Tools List 事件处理器
+ * 处理云端下发的 TOOLS_LIST EVENT 消息
+ * 从 OpenClaw 获取 tools 列表并通过 HTTP 回调返回
+ */
+
+import { fetch } from 'undici'
+
+export interface ToolsListEvent {
+  agentId: string | number
+  userId: string | number
+}
+
+export interface ToolItem {
+  typeStr: string
+  name: string
+  description: string
+}
+
+export interface ToolsListCallbackPayload {
+  userId: number
+  agentId: number
+  dataList: ToolItem[]
+}
+
+/**
+ * 处理 TOOLS_LIST 事件
+ * @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
+  },
+): Promise<void> {
+  const agentId = Number(event.agentId)
+  const userId = Number(event.userId)
+
+  log?.info?.(`ToolsList: Handling TOOLS_LIST event for agentId: ${agentId}, userId: ${userId}`)
+
+  try {
+    // 从 OpenClaw 获取 tools 列表
+    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)
+
+    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
+  }
+}
+
+/**
+ * 从 OpenClaw 获取 tools 列表
+ * 根据 agent 的 tools.allow 配置决定返回哪些工具
+ */
+async function fetchToolsFromOpenClaw(
+  agentId: number,
+  _userId: number,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): Promise<ToolItem[]> {
+  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.' },
+  ]
+
+  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)
+
+    // 查找对应的 agent 配置
+    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
+
+    // 如果没有 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
+    }
+
+    // 如果有具体的 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`)
+    // 如果读取配置失败，返回所有工具
+    return allTools
+  }
+}
+
+/**
+ * 发送 tools 列表回调
+ */
+async function sendToolsListCallback(
+  callbackUrl: string,
+  payload: ToolsListCallbackPayload,
+  token: string,
+  log?: {
+    info?: (msg: string) => void
+    error?: (msg: string) => void
+  },
+): Promise<void> {
+  log?.info?.(`ToolsList: Sending callback to ${callbackUrl}`)
+
+  const response = await fetch(callbackUrl, {
+    method: 'POST',
+    headers: {
+      '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}`)
+  }
+
+  log?.info?.(`ToolsList: Callback sent successfully: ${response.status}`)
+}