@eyeclaw/eyeclaw 2.0.14 → 2.2.0

package/src/websocket-client.ts

@@ -0,0 +1,316 @@
+/**
+ * EyeClaw SDK - WebSocket Client
+ * 
+ * 连接到 Rails 服务器，接收消息并流式返回
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
+import type { EyeClawConfig } from './types.js'
+
+interface WebSocketMessage {
+  type: string
+  [key: string]: any
+}
+
+interface ActionCableMessage {
+  identifier: string
+  message: WebSocketMessage
+}
+
+export class EyeClawWebSocketClient {
+  private ws: WebSocket | null = null
+  private api: OpenClawPluginApi
+  private config: EyeClawConfig
+  private reconnectAttempts = 0
+  private maxReconnectAttempts = 5
+  private reconnectDelay = 3000
+  private subscribed = false
+  private pingInterval: any = null
+
+  constructor(api: OpenClawPluginApi, config: EyeClawConfig) {
+    this.api = api
+    this.config = config
+  }
+
+  /**
+   * 启动 WebSocket 连接
+   */
+  async start() {
+    const { serverUrl, sdkToken, botId } = this.config
+    
+    if (!serverUrl || !sdkToken || !botId) {
+      this.api.logger.warn('[EyeClaw] WebSocket: Missing config (serverUrl, sdkToken, or botId)')
+      return
+    }
+
+    const wsUrl = serverUrl.replace(/^http/, 'ws') + `/cable?sdk_token=${sdkToken}&bot_id=${botId}`
+    this.api.logger.info(`[EyeClaw] WebSocket connecting to: ${wsUrl}`)
+
+    try {
+      // @ts-ignore - WebSocket 在 Node 环境中可用
+      this.ws = new WebSocket(wsUrl)
+
+      this.ws.onopen = () => {
+        this.api.logger.info('[EyeClaw] WebSocket connected')
+        this.reconnectAttempts = 0
+      }
+
+      this.ws.onmessage = (event) => {
+        this.handleMessage(event.data)
+      }
+
+      this.ws.onerror = (error) => {
+        this.api.logger.error(`[EyeClaw] WebSocket error: ${error}`)
+      }
+
+      this.ws.onclose = () => {
+        this.api.logger.warn('[EyeClaw] WebSocket disconnected')
+        this.subscribed = false
+        this.stopPing()
+        this.scheduleReconnect()
+      }
+
+    } catch (error) {
+      this.api.logger.error(`[EyeClaw] WebSocket connection failed: ${error}`)
+      this.scheduleReconnect()
+    }
+  }
+
+  /**
+   * 停止 WebSocket 连接
+   */
+  stop() {
+    this.stopPing()
+    if (this.ws) {
+      this.ws.close()
+      this.ws = null
+    }
+    this.subscribed = false
+  }
+
+  /**
+   * 处理 WebSocket 消息
+   */
+  private handleMessage(data: string) {
+    try {
+      const message = JSON.parse(data)
+
+      // Welcome message
+      if (message.type === 'welcome') {
+        this.api.logger.info('[EyeClaw] Received welcome, subscribing...')
+        this.subscribe()
+        return
+      }
+
+      // Ping/pong
+      if (message.type === 'ping') {
+        this.send({ type: 'pong' })
+        return
+      }
+
+      // Subscription confirmation
+      if (message.type === 'confirm_subscription') {
+        this.api.logger.info('[EyeClaw] ✅ Subscribed to channel')
+        this.subscribed = true
+        this.startPing()
+        return
+      }
+
+      // Rejection
+      if (message.type === 'reject_subscription') {
+        this.api.logger.error('[EyeClaw] ❌ Subscription rejected')
+        return
+      }
+
+      // 实际消息 - 从 Rails 发送的消息
+      if (message.identifier && message.message) {
+        const payload = message.message
+        this.handleCommand(payload)
+      }
+
+    } catch (error) {
+      this.api.logger.error(`[EyeClaw] Failed to parse message: ${error}`)
+    }
+  }
+
+  /**
+   * 订阅到 BotChannel
+   */
+  private subscribe() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return
+
+    const channelIdentifier = JSON.stringify({
+      channel: 'BotChannel',
+      bot_id: this.config.botId,
+    })
+
+    this.send({
+      command: 'subscribe',
+      identifier: channelIdentifier,
+    })
+  }
+
+  /**
+   * 处理命令消息
+   */
+  private async handleCommand(payload: WebSocketMessage) {
+    const { type, message: text, session_id, command } = payload
+
+    // 只处理 execute_command 类型的消息
+    if (type !== 'execute_command' && type !== 'chat') {
+      return
+    }
+
+    const userMessage = text || command
+    if (!userMessage) {
+      this.api.logger.warn('[EyeClaw] No message content')
+      return
+    }
+
+    this.api.logger.info(`[EyeClaw] Processing: ${userMessage.substring(0, 50)}...`)
+
+    // 通过 OpenClaw API 处理消息，获取流式响应
+    await this.processWithOpenClaw(userMessage, session_id)
+  }
+
+  /**
+   * 使用 OpenClaw API 处理消息（流式）
+   */
+  private async processWithOpenClaw(message: string, sessionId?: string) {
+    const gatewayPort = this.api.config?.gateway?.port ?? 18789
+    const gatewayToken = this.api.config?.gateway?.auth?.token
+
+    const openclawUrl = `http://127.0.0.1:${gatewayPort}/v1/chat/completions`
+    const openclawBody = {
+      model: 'openclaw:main',
+      stream: true,
+      messages: [{ role: 'user', content: message }],
+      user: sessionId ? `eyeclaw:${sessionId}` : 'eyeclaw:ws',
+    }
+
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+    if (gatewayToken) headers['Authorization'] = `Bearer ${gatewayToken}`
+
+    try {
+      const response = await fetch(openclawUrl, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(openclawBody),
+      })
+
+      if (!response.ok) {
+        const errorText = await response.text()
+        throw new Error(`OpenClaw API error: ${response.status} - ${errorText}`)
+      }
+
+      const reader = response.body?.getReader()
+      if (!reader) throw new Error('No response body')
+
+      const decoder = new TextDecoder()
+      let buffer = ''
+
+      // 发送流式响应回 Rails
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+
+        buffer += decoder.decode(value, { stream: true })
+        const lines = buffer.split('\n')
+        buffer = lines.pop() || ''
+
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (!trimmed.startsWith('data: ')) continue
+          const data = trimmed.slice(6)
+          if (data === '[DONE]') continue
+
+          try {
+            const chunk = JSON.parse(data)
+            const content = chunk.choices?.[0]?.delta?.content
+            if (content) {
+              this.sendChunk(content, sessionId)
+            }
+          } catch { /* ignore */ }
+        }
+      }
+
+      // 发送完成信号
+      this.sendMessage('stream_end', { session_id: sessionId })
+
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error)
+      this.api.logger.error(`[EyeClaw] OpenClaw error: ${errorMsg}`)
+      this.sendMessage('stream_error', { error: errorMsg, session_id: sessionId })
+    }
+  }
+
+  /**
+   * 通过 WebSocket 发送消息到 Rails
+   */
+  private send(data: any) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return
+    this.ws.send(JSON.stringify(data))
+  }
+
+  /**
+   * 发送流式内容块到 Rails
+   */
+  private sendChunk(content: string, sessionId?: string) {
+    this.send({
+      type: 'stream_chunk',
+      content,
+      session_id: sessionId,
+    })
+  }
+
+  /**
+   * 发送消息到 Rails（带 channel identifier）
+   */
+  private sendMessage(type: string, data: any) {
+    const channelIdentifier = JSON.stringify({
+      channel: 'BotChannel',
+      bot_id: this.config.botId,
+    })
+
+    this.send({
+      command: 'message',
+      identifier: channelIdentifier,
+      data: { type, ...data },
+    })
+  }
+
+  /**
+   * 启动心跳
+   */
+  private startPing() {
+    this.pingInterval = setInterval(() => {
+      this.send({ type: 'ping' })
+    }, 30000)
+  }
+
+  /**
+   * 停止心跳
+   */
+  private stopPing() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval)
+      this.pingInterval = null
+    }
+  }
+
+  /**
+   * 计划重连
+   */
+  private scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.api.logger.error('[EyeClaw] Max reconnect attempts reached')
+      return
+    }
+
+    this.reconnectAttempts++
+    this.api.logger.info(`[EyeClaw] Reconnecting in ${this.reconnectDelay}ms (attempt ${this.reconnectAttempts})`)
+
+    setTimeout(() => {
+      this.start()
+    }, this.reconnectDelay)
+  }
+}

package/src/channel.ts

@@ -1,295 +0,0 @@
-import type { ChannelPlugin } from 'openclaw/plugin-sdk'
-import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk'
-import type { EyeClawConfig, ResolvedEyeClawAccount } from './types.js'
-import { EyeClawClient } from './client.js'
-
-// Active clients map (accountId -> client)
-const clients = new Map<string, EyeClawClient>()
-
-// Store runtime for use in gateway.startAccount (set during plugin registration)
-let _runtime: any = null
-
-/**
- * Set the plugin runtime (called during plugin registration)
- */
-export function setRuntime(runtime: any) {
-  _runtime = runtime
-}
-
-export function getRuntime() {
-  return _runtime
-}
-
-/**
- * Resolve EyeClaw account configuration
- */
-function resolveEyeClawAccount(cfg: any, accountId: string): ResolvedEyeClawAccount {
-  const eyeclawConfig: EyeClawConfig = cfg?.channels?.eyeclaw || {}
-  
-  // Default account uses top-level config
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    return {
-      accountId: DEFAULT_ACCOUNT_ID,
-      enabled: eyeclawConfig.enabled !== false,
-      configured: !!(eyeclawConfig.botId && eyeclawConfig.sdkToken),
-      name: 'Default',
-      config: eyeclawConfig,
-    }
-  }
-  
-  // Named accounts not supported yet
-  throw new Error(`Named accounts not yet supported for EyeClaw`)
-}
-
-/**
- * List all EyeClaw account IDs
- */
-function listEyeClawAccountIds(cfg: any): string[] {
-  return [DEFAULT_ACCOUNT_ID]
-}
-
-/**
- * EyeClaw Channel Plugin
- */
-export const eyeclawPlugin: ChannelPlugin<ResolvedEyeClawAccount> = {
-  id: 'eyeclaw',
-  
-  meta: {
-    id: 'eyeclaw',
-    label: 'EyeClaw',
-    selectionLabel: 'EyeClaw Platform',
-    docsPath: '/channels/eyeclaw',
-    docsLabel: 'eyeclaw',
-    blurb: 'EyeClaw platform integration via WebSocket.',
-    order: 100,
-  },
-  
-  capabilities: {
-    chatTypes: ['direct', 'channel'],
-    polls: false,
-    threads: false,
-    media: false,
-    reactions: false,
-    edit: false,
-    reply: false,
-  },
-  
-  reload: { configPrefixes: ['channels.eyeclaw'] },
-  
-  configSchema: {
-    schema: {
-      type: 'object',
-      additionalProperties: true,
-      properties: {
-        enabled: {
-          type: 'boolean',
-          description: 'Enable/disable the plugin',
-        },
-        botId: {
-          type: ['string', 'number'],
-          description: 'Bot ID from EyeClaw platform',
-        },
-        sdkToken: {
-          type: 'string',
-          description: 'SDK token for authentication',
-        },
-        serverUrl: {
-          type: 'string',
-          description: 'EyeClaw server URL',
-        },
-        reconnectInterval: {
-          type: 'number',
-          description: 'Reconnect interval in milliseconds',
-        },
-        heartbeatInterval: {
-          type: 'number',
-          description: 'Heartbeat interval in milliseconds',
-        },
-      },
-    },
-  },
-  
-  config: {
-    listAccountIds: (cfg) => listEyeClawAccountIds(cfg),
-    resolveAccount: (cfg, accountId) => resolveEyeClawAccount(cfg, accountId || DEFAULT_ACCOUNT_ID),
-    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-  },
-  
-  status: {
-    defaultRuntime: {
-      accountId: DEFAULT_ACCOUNT_ID,
-      running: false,
-      lastStartAt: null,
-      lastStopAt: null,
-      lastError: null,
-    },
-    
-    buildChannelSummary: ({ snapshot }) => ({
-      configured: snapshot.configured ?? false,
-      running: snapshot.running ?? false,
-      lastStartAt: snapshot.lastStartAt ?? null,
-      lastStopAt: snapshot.lastStopAt ?? null,
-      lastError: snapshot.lastError ?? null,
-    }),
-    
-    probeAccount: async ({ account }) => {
-      // Simple probe - check if configured
-      return {
-        ok: account.configured,
-        message: account.configured ? 'Configured' : 'Not configured',
-      }
-    },
-    
-    buildAccountSnapshot: ({ account, runtime, probe }) => ({
-      accountId: account.accountId,
-      enabled: account.enabled,
-      configured: account.configured,
-      name: account.name,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      probe,
-    }),
-  },
-
-  gateway: {
-    startAccount: async (ctx: any) => {
-      const account = resolveEyeClawAccount(ctx.cfg, ctx.accountId)
-      
-      if (!account.configured || !account.config) {
-        throw new Error('EyeClaw not configured. Please set botId and sdkToken.')
-      }
-      
-      const config = account.config
-      
-      // Validate required fields
-      if (!config.botId || !config.sdkToken) {
-        throw new Error('botId and sdkToken are required')
-      }
-      
-      // Set defaults
-      const clientConfig = {
-        botId: String(config.botId),
-        sdkToken: config.sdkToken,
-        serverUrl: config.serverUrl || 'http://localhost:3000',
-        reconnectInterval: config.reconnectInterval || 5000,
-        heartbeatInterval: config.heartbeatInterval || 30000,
-        enabled: true,
-      }
-      
-      ctx.log?.info(`🦞 Starting EyeClaw SDK... botId=${clientConfig.botId}, serverUrl=${clientConfig.serverUrl}`)
-      
-      // Create logger adapter
-      const logger = {
-        debug: (msg: string) => ctx.log?.debug?.(msg),
-        info: (msg: string) => ctx.log?.info(msg),
-        warn: (msg: string) => ctx.log?.warn(msg),
-        error: (msg: string) => ctx.log?.error(msg),
-      }
-      
-      // Get runtime from module-level storage (set during register)
-      const runtime = getRuntime()
-      if (!runtime) {
-        throw new Error('OpenClaw runtime not available - did you install the plugin correctly?')
-      }
-      
-      // Create and connect client
-      const client = new EyeClawClient(clientConfig, logger)
-      clients.set(ctx.accountId, client)
-      
-      // Register OpenClaw Agent callback for chat messages
-      // Use runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher for true streaming
-      client.setSendAgentCallback(async (message: string) => {
-        const streamId = Date.now().toString()
-        const streamKey = 'eyeclaw-web-chat'
-        
-        try {
-          ctx.log?.info(`🤖 Processing message via OpenClaw dispatchReply: ${message}`)
-          
-          // 发送 stream_start
-          client.sendStreamChunk('stream_start', streamId, '')
-          
-          // 使用 OpenClaw 的 dispatchReplyWithBufferedBlockDispatcher 实现真正的流式
-          // 这和 WeCom 插件使用的方式完全相同
-          // API 路径: runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher
-          await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-            ctx: {
-              // Inbound message context
-              sessionKey: `eyeclaw:${streamKey}`,
-              messageKey: `eyeclaw:${streamKey}:${streamId}`,
-              peerKey: streamKey,
-              message: {
-                role: 'user',
-                content: message,
-                roleDetail: 'user',
-              },
-            },
-            cfg: ctx.cfg,
-            dispatcherOptions: {
-              // 流式回调 - LLM 每生成一块文本就实时调用
-              deliver: async (payload: any, info: any) => {
-                const text = payload.text || ''
-                if (text) {
-                  ctx.log?.debug(`Delivering chunk: ${text.substring(0, 50)}...`)
-                  client.sendStreamChunk('stream_chunk', streamId, text)
-                }
-                
-                // 当主响应完成时记录
-                if (info.kind === 'final') {
-                  ctx.log?.info('Main response complete')
-                }
-              },
-              onError: async (error: any, info: any) => {
-                ctx.log?.error(`Reply failed: ${error.message}`)
-                client.sendStreamChunk('stream_error', streamId, error.message)
-              },
-            },
-          })
-          
-          // 发送 stream_end
-          client.sendStreamChunk('stream_end', streamId, '')
-          ctx.log?.info(`✅ Message processed successfully`)
-          
-        } catch (error) {
-          const errorMsg = error instanceof Error ? error.message : String(error)
-          ctx.log?.error(`Failed to process message: ${errorMsg}`)
-          // 发送错误通知
-          try {
-            client.sendStreamChunk('stream_error', streamId, errorMsg)
-            client.sendLog('error', `❌ Error: ${errorMsg}`)
-          } catch (sendError) {
-            ctx.log?.error(`Failed to send error notification: ${sendError}`)
-          }
-        }
-      })
-      
-      try {
-        await client.connect()
-        ctx.log?.info('✅ Successfully connected to EyeClaw platform')
-        ctx.setStatus({ accountId: ctx.accountId, running: true, lastStartAt: Date.now() })
-        
-        // Wait for abort signal
-        await new Promise<void>((resolve) => {
-          ctx.abortSignal.addEventListener('abort', () => {
-            ctx.log?.info('🛑 Shutting down EyeClaw SDK...')
-            client.disconnect()
-            clients.delete(ctx.accountId)
-            ctx.setStatus({ accountId: ctx.accountId, running: false, lastStopAt: Date.now() })
-            resolve()
-          })
-        })
-      } catch (error) {
-        const errorMsg = error instanceof Error ? error.message : String(error)
-        ctx.log?.error(`Failed to connect to EyeClaw: ${errorMsg}`)
-        ctx.setStatus({ 
-          accountId: ctx.accountId, 
-          running: false, 
-          lastError: errorMsg,
-          lastStopAt: Date.now(),
-        })
-        throw error
-      }
-    },
-  },
-}