@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

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

@@ -1,332 +0,0 @@
-import { execSync } from 'node:child_process'
-
-/**
- * Skills list handler - 处理 SKILLS_LIST 事件
- * 从 OpenClaw 获取 skills 列表并通过回调返回
- */
-import { readFileSync } from 'node:fs'
-import { existsSync, readdirSync, statSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-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 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 agentWorkspace = join(homedir(), '.openclaw', 'agents', `openclaw-workclaw-${agentId}`)
-    const skillsDir = join(agentWorkspace, 'skills')
-
-    // 检查技能目录是否存在
-    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

@@ -1,161 +0,0 @@
-/**
- * Tools List 事件处理器
- * 处理云端下发的 TOOLS_LIST EVENT 消息
- * 从 OpenClaw 获取 tools 列表并通过 HTTP 回调返回
- */
-
-import { readFile } from 'node:fs/promises'
-import { homedir } from 'node:os'
-import path from 'node:path'
-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 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}`)
-}