@eyeclaw/eyeclaw 2.0.14 → 2.2.0

package/index.ts

@@ -1,31 +1,63 @@
+/**
+ * EyeClaw SDK - OpenClaw Plugin
+ * 
+ * 支持两种模式：
+ * 1. HTTP 端点：外部直接调用 POST /eyeclaw/chat，SSE 流式返回
+ * 2. WebSocket：连接 Rails 服务器，接收消息并流式返回
+ */
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk'
-import { eyeclawPlugin, setRuntime } from './src/channel.js'
+import { createHttpHandler, eyeclawConfigSchema } from './src/http-handler.js'
+import { EyeClawWebSocketClient } from './src/websocket-client.js'
+import type { EyeClawConfig } from './src/types.js'
 
 /**
- * EyeClaw SDK - OpenClaw Channel Plugin
- * 
- * Connects local OpenClaw instance to EyeClaw platform via WebSocket.
+ * EyeClaw 插件
  */
-const plugin = {
+const eyeclawPlugin = {
   id: 'eyeclaw',
   name: 'EyeClaw',
-  description: 'EyeClaw platform channel plugin',
-  configSchema: emptyPluginConfigSchema(),
+  description: 'EyeClaw 消息转发插件 - HTTP SSE 流式 + WebSocket 客户端',
+  configSchema: eyeclawConfigSchema,
   
   register(api: OpenClawPluginApi) {
-    // Save runtime for message processing (like WeCom plugin does)
-    // This allows channel.ts to access runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher
-    setRuntime(api.runtime)
+    const logger = api.logger
     
-    // Register EyeClaw as a channel plugin
-    api.registerChannel({ plugin: eyeclawPlugin })
+    // 解析配置
+    const rawConfig = api.config?.plugins?.entries?.eyeclaw?.config
+    const config: EyeClawConfig = {
+      sdkToken: rawConfig?.sdkToken || '',
+      botId: rawConfig?.botId || '',
+      serverUrl: rawConfig?.serverUrl || '',
+    }
+    
+    // HTTP 处理器（SSE 流式）
+    api.registerHttpHandler(createHttpHandler(api, () => config))
+    logger.info('[EyeClaw] HTTP handler registered: /eyeclaw/*')
+    
+    // WebSocket 客户端（连接 Rails 接收消息）
+    if (config.sdkToken && config.botId && config.serverUrl) {
+      const wsClient = new EyeClawWebSocketClient(api, config)
+      wsClient.start()
+      logger.info('[EyeClaw] WebSocket client starting...')
+      
+      // 存储客户端引用，防止被垃圾回收
+      ;(global as any).__eyeclaw_ws = wsClient
+    } else {
+      logger.warn('[EyeClaw] WebSocket not started: missing config (sdkToken, botId, serverUrl)')
+    }
+    
+    // 打印启动信息
+    const gatewayPort = api.config?.gateway?.port ?? 18789
+    console.log('')
+    console.log('╔═══════════════════════════════════════════════════════════════════════╗')
+    console.log('║ EyeClaw Plugin 已启动                                                ║')
+    console.log('╠═══════════════════════════════════════════════════════════════════════╣')
+    console.log(`║ HTTP 端点: POST http://127.0.0.1:${gatewayPort}/eyeclaw/chat         ║`)
+    console.log(`║ WebSocket: ${config.serverUrl ? '已配置' : '未配置'}                                            ║`)
+    console.log(`║ SDK Token: ${config.sdkToken ? config.sdkToken.substring(0, 8) + '...' : '未配置'}                                          ║`)
+    console.log('╚═══════════════════════════════════════════════════════════════════════╝')
+    console.log('')
   },
 }
 
-export default plugin
-
-// Re-export for direct usage
-export { EyeClawClient } from './src/client.js'
-export * from './src/types.js'
-export { eyeclawPlugin } from './src/channel.js'
+export default eyeclawPlugin

package/openclaw.plugin.json

@@ -1,34 +1,21 @@
 {
   "id": "eyeclaw",
-  "channels": ["eyeclaw"],
   "configSchema": {
     "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": {
+      "botId": {
         "type": "string",
-        "description": "EyeClaw server URL"
-      },
-      "reconnectInterval": {
-        "type": "number",
-        "description": "Reconnect interval in milliseconds"
+        "description": "Bot ID in EyeClaw Rails app"
       },
-      "heartbeatInterval": {
-        "type": "number",
-        "description": "Heartbeat interval in milliseconds"
+      "serverUrl": {
+        "type": "string",
+        "description": "EyeClaw Rails server URL (e.g., http://localhost:3000)"
       }
-    }
+    },
+    "required": ["sdkToken", "botId", "serverUrl"]
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eyeclaw/eyeclaw",
-  "version": "2.0.14",
-  "description": "EyeClaw channel plugin for OpenClaw - Connect your local OpenClaw instance to EyeClaw platform",
+  "version": "2.2.0",
+  "description": "EyeClaw plugin for OpenClaw - HTTP SSE streaming + WebSocket client",
   "type": "module",
   "main": "./index.ts",
   "types": "./index.ts",
@@ -16,9 +16,9 @@
     "openclaw",
     "eyeclaw",
     "plugin",
-    "channel",
-    "mcp",
-    "websocket"
+    "http",
+    "sse",
+    "streaming"
   ],
   "author": "EyeClaw Team",
   "license": "MIT",
@@ -35,24 +35,12 @@
     "extensions": [
       "./index.ts"
     ],
-    "channel": {
-      "id": "eyeclaw",
-      "label": "EyeClaw",
-      "selectionLabel": "EyeClaw Platform",
-      "blurb": "Connect local OpenClaw to EyeClaw platform via WebSocket.",
-      "order": 100
-    },
     "install": {
       "npmSpec": "@eyeclaw/eyeclaw",
       "localPath": ".",
       "defaultChoice": "npm"
     }
   },
-  "dependencies": {
-    "ws": "^8.16.0",
-    "@types/ws": "^8.5.10",
-    "zod": "^3.22.4"
-  },
   "peerDependencies": {
     "openclaw": ">=2026.2.3"
   },

package/src/cli.ts

@@ -1,36 +1,34 @@
 #!/usr/bin/env node
-import chalk from 'chalk'
 
 /**
  * EyeClaw SDK CLI
  * 
  * This file provides a minimal CLI interface for the plugin.
- * The actual installation is handled by: openclaw plugins install @eyeclaw/sdk
+ * The actual installation is handled by: openclaw plugins install @eyeclaw/eyeclaw
  */
 
 const USAGE = `
-${chalk.bold.blue('EyeClaw SDK')} - Connect your local OpenClaw to EyeClaw platform
+${'Use chalk.bold.blue'}(    'EyeClaw SDK')} - Connect your local OpenClaw to EyeClaw platform
 
-${chalk.bold('Installation:')}
-  ${chalk.cyan('openclaw plugins install @eyeclaw/sdk')}
+${'Use chalk.bold'}(    'Installation:')}
+  ${'Use chalk.cyan'}(    'openclaw plugins install @eyeclaw/eyeclaw')}
 
-${chalk.bold('Configuration:')}
-  ${chalk.cyan('openclaw config set channels.eyeclaw.enabled true')}
-  ${chalk.cyan('openclaw config set channels.eyeclaw.botId "your-bot-id"')}
-  ${chalk.cyan('openclaw config set channels.eyeclaw.sdkToken "your-sdk-token"')}
-  ${chalk.cyan('openclaw config set channels.eyeclaw.serverUrl "https://eyeclaw.io"')}
+${'Use chalk.bold'}(    'Configuration:')}
+  ${'Use chalk.cyan'}(    'openclaw config set plugins.eyeclaw.sdkToken "your-sdk-token"')}
 
-${chalk.bold('Upgrade:')}
-  ${chalk.cyan('openclaw plugins update eyeclaw')}
+${'Use chalk.bold'}(    'HTTP Endpoint:')}
+  ${'Use chalk.cyan'}(    'POST http://127.0.0.1:18789/eyeclaw/chat')}
+  Headers: Authorization: Bearer <sdkToken>
+  Body: { "message": "Hello" }
 
-${chalk.bold('Uninstall:')}
-  ${chalk.cyan('openclaw plugins uninstall eyeclaw')}
+${'Use chalk.bold'}(    'Upgrade:')}
+  ${'Use chalk.cyan'}(    'openclaw plugins update eyeclaw')}
 
-${chalk.bold('Documentation:')}
-  ${chalk.cyan('https://eyeclaw.io/docs')}
+${'Use chalk.bold'}(    'Uninstall:')}
+  ${'Use chalk.cyan'}(    'openclaw plugins uninstall eyeclaw')}
 
-${chalk.bold('Support:')}
-  ${chalk.cyan('https://github.com/eyeclaw/eyeclaw/issues')}
+${'Use chalk.bold'}(    'Documentation:')}
+  ${'Use chalk.cyan'}(    'https://eyeclaw.io/docs')}
 `
 
 function main() {
@@ -42,16 +40,14 @@ function main() {
   }
 
   if (args.includes('--version') || args.includes('-v')) {
-    // Read version from package.json
     const pkg = require('../package.json')
     console.log(`v${pkg.version}`)
     process.exit(0)
   }
 
-  // Default: show usage
   console.log(USAGE)
-  console.log(chalk.yellow('ℹ This is an OpenClaw plugin. Please install it using:'))
-  console.log(chalk.cyan('  openclaw plugins install @eyeclaw/eyeclaw\n'))
+  console.log('ℹ This is an OpenClaw plugin. Please install it using:')
+  console.log('  openclaw plugins install @eyeclaw/eyeclaw\n')
 }
 
 main()

package/src/http-handler.ts

@@ -0,0 +1,208 @@
+/**
+ * EyeClaw SDK - OpenClaw HTTP Handler Plugin
+ * 
+ * 直接注册 HTTP 端点，实现真正的 SSE 流式转发
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
+import type { EyeClawConfig } from './types.js'
+
+/**
+ * 读取 JSON 请求体
+ */
+async function readJsonBody(req: IncomingMessage): Promise<any> {
+  const chunks: Buffer[] = []
+  return new Promise((resolve, reject) => {
+    req.on('data', (chunk) => chunks.push(chunk))
+    req.on('end', () => {
+      try {
+        const body = Buffer.concat(chunks).toString('utf-8')
+        resolve(body ? JSON.parse(body) : {})
+      } catch (e) {
+        reject(e)
+      }
+    })
+    req.on('error', (e) => reject(e))
+  })
+}
+
+/**
+ * 验证 Authorization 头
+ */
+function verifyAuth(authHeader: string | string[] | undefined, expectedToken: string): boolean {
+  if (!expectedToken) return true
+  const header = Array.isArray(authHeader) ? authHeader[0] : authHeader
+  if (!header) return false
+  if (header.startsWith('Bearer ')) return header.slice(7) === expectedToken
+  return header === expectedToken
+}
+
+/**
+ * 格式化 SSE 响应
+ */
+function formatSSE(event: string, data: any): string {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+}
+
+/**
+ * 创建 HTTP 处理器
+ */
+export function createHttpHandler(api: OpenClawPluginApi, getConfig: () => EyeClawConfig) {
+  return async function handler(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
+    const url = new URL(req.url ?? '/', 'http://localhost')
+    if (!url.pathname.startsWith('/eyeclaw/')) return false
+    
+    const logger = api.logger
+    const config = getConfig()
+    
+    // 验证鉴权
+    const authHeader = req.headers.authorization
+    if (!verifyAuth(authHeader, config.sdkToken || '')) {
+      logger.warn('[EyeClaw] Unauthorized request')
+      res.statusCode = 401
+      res.setHeader('Content-Type', 'application/json')
+      res.end(JSON.stringify({ error: 'Unauthorized' }))
+      return true
+    }
+    
+    if (req.method !== 'POST') {
+      res.statusCode = 405
+      res.setHeader('Allow', 'POST')
+      res.end('Method Not Allowed')
+      return true
+    }
+    
+    try {
+      const body = await readJsonBody(req)
+      const { message, session_id, stream_id } = body
+      
+      if (!message) {
+        res.statusCode = 400
+        res.setHeader('Content-Type', 'application/json')
+        res.end(JSON.stringify({ error: 'Missing required field: message' }))
+        return true
+      }
+      
+      logger.info(`[EyeClaw] Chat: ${message.substring(0, 50)}...`)
+      
+      // SSE 响应头
+      res.setHeader('Content-Type', 'text/event-stream')
+      res.setHeader('Cache-Control', 'no-cache')
+      res.setHeader('Connection', 'keep-alive')
+      res.setHeader('X-Accel-Buffering', 'no')
+      
+      // 获取 Gateway 配置
+      const gatewayPort = api.config?.gateway?.port ?? 18789
+      const gatewayToken = api.config?.gateway?.auth?.token
+      const sessionKey = session_id ? `eyeclaw:${session_id}` : 'eyeclaw:default'
+      
+      // 调用 OpenClaw
+      const openclawUrl = `http://127.0.0.1:${gatewayPort}/v1/chat/completions`
+      const openclawBody = {
+        model: 'openclaw:main',
+        stream: true,
+        messages: [{ role: 'user', content: message }],
+        user: sessionKey,
+      }
+      
+      const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+      if (gatewayToken) headers['Authorization'] = `Bearer ${gatewayToken}`
+      
+      logger.info(`[EyeClaw] Calling OpenClaw: ${openclawUrl}`)
+      
+      const openclawResponse = await fetch(openclawUrl, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(openclawBody),
+      })
+      
+      if (!openclawResponse.ok) {
+        const errorText = await openclawResponse.text()
+        throw new Error(`OpenClaw API error: ${openclawResponse.status} - ${errorText}`)
+      }
+      
+      const reader = openclawResponse.body?.getReader()
+      if (!reader) throw new Error('No response body')
+      
+      const decoder = new TextDecoder()
+      let buffer = ''
+      const currentStreamId = stream_id || Date.now().toString()
+      
+      res.write(formatSSE('stream_start', { stream_id: currentStreamId }))
+      
+      // 保活
+      const keepaliveInterval = setInterval(() => { try { res.write(': keepalive\n\n') } catch { clearInterval(keepaliveInterval) } }, 7000)
+      
+      try {
+        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) {
+                res.write(formatSSE('stream_chunk', { stream_id: currentStreamId, content }))
+              }
+            } catch { /* ignore */ }
+          }
+        }
+      } finally {
+        clearInterval(keepaliveInterval)
+      }
+      
+      res.write(formatSSE('stream_end', { stream_id: currentStreamId }))
+      res.end()
+      logger.info(`[EyeClaw] Completed: ${currentStreamId}`)
+      return true
+      
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error)
+      logger.error(`[EyeClaw] Error: ${errorMsg}`)
+      res.write(formatSSE('stream_error', { error: errorMsg }))
+      res.end()
+      return true
+    }
+  }
+}
+
+/**
+ * 插件配置 Schema
+ */
+export const eyeclawConfigSchema = {
+  safeParse: (value: unknown) => {
+    if (!value || typeof value !== 'object') {
+      return { success: false, errors: ['Expected config object'] }
+    }
+    const cfg = value as any
+    if (!cfg.sdkToken) {
+      return { success: false, errors: ['sdkToken is required'] }
+    }
+    if (!cfg.botId) {
+      return { success: false, errors: ['botId is required'] }
+    }
+    if (!cfg.serverUrl) {
+      return { success: false, errors: ['serverUrl is required'] }
+    }
+    return { success: true, data: cfg }
+  },
+  jsonSchema: {
+    type: 'object',
+    properties: {
+      sdkToken: { type: 'string', description: 'EyeClaw SDK Token' },
+      botId: { type: 'string', description: 'Bot ID in EyeClaw Rails app' },
+      serverUrl: { type: 'string', description: 'EyeClaw Rails server URL' },
+    },
+    required: ['sdkToken', 'botId', 'serverUrl'],
+  },
+}

package/src/types.ts

@@ -1,36 +1,9 @@
-// Type definitions for EyeClaw Channel Plugin
+// Type definitions for EyeClaw Plugin
 
 export interface EyeClawConfig {
-  enabled?: boolean
-  botId: string | number
   sdkToken: string
-  serverUrl?: string
-  reconnectInterval?: number
-  heartbeatInterval?: number
-}
-
-export interface ResolvedEyeClawAccount {
-  accountId: string
-  enabled: boolean
-  configured: boolean
-  name: string
-  config?: EyeClawConfig
-}
-
-export interface PluginConfig {
-  enabled: boolean
   botId: string
-  sdkToken: string
   serverUrl: string
-  reconnectInterval?: number
-  heartbeatInterval?: number
-}
-
-export interface OpenClawContext {
-  config: PluginConfig
-  logger: Logger
-  emit: (event: string, data: unknown) => void
-  on: (event: string, handler: (data: unknown) => void) => void
 }
 
 export interface Logger {
@@ -40,14 +13,6 @@ export interface Logger {
   debug: (message: string) => void
 }
 
-export interface ChannelMessage {
-  type: string
-  content?: string
-  role?: 'user' | 'assistant'
-  timestamp?: string
-  metadata?: Record<string, unknown>
-}
-
 export interface BotStatus {
   online: boolean
   status: string