@eyeclaw/eyeclaw 2.0.0 → 2.0.4

package/README.md

@@ -212,6 +212,112 @@ client.disconnect()
 - **Issues**: [https://github.com/eyeclaw/eyeclaw/issues](https://github.com/eyeclaw/eyeclaw/issues)
 - **Discord**: [https://discord.gg/eyeclaw](https://discord.gg/eyeclaw)
 
+## 💬 Chat Functionality
+
+The EyeClaw SDK includes built-in chat functionality that allows you to interact with your bot through the web dashboard.
+
+### Testing Chat
+
+1. Start your bot with the EyeClaw plugin installed
+2. Go to your bot's detail page on EyeClaw Dashboard
+3. Click **"Test Chat"** button
+4. Send messages - the bot will respond with smart replies
+5. Use quick test buttons:
+   - **Ping** - Test bot connectivity
+   - **Status** - Get bot status (online, sessions, uptime)
+   - **Echo** - Echo back a test message
+   - **Help** - Show available commands
+
+### Supported Commands
+
+The SDK automatically handles these commands from the web dashboard:
+
+- **`chat`** - Receive and respond to chat messages
+  - Params: `{ message: string }`
+  - The bot uses pattern matching to generate smart responses
+  - Supports greetings, questions, thanks, farewells in Chinese and English
+
+- **`ping`** - Test bot connectivity
+  - Response: "🏓 Pong! Bot is responding."
+
+- **`status`** - Get current bot status
+  - Returns: online status, active sessions, total sessions, uptime
+
+- **`echo`** - Echo back a message
+  - Params: `{ message: string }`
+  - Response: Echoes the message back
+
+- **`help`** - Show available commands
+  - Response: Lists all available commands and their usage
+
+### Customizing Bot Responses
+
+You can customize the bot's chat responses by modifying `generateBotReply()` in `sdk/src/client.ts`:
+
+```typescript
+private generateBotReply(userMessage: string): string {
+  const lowerMessage = userMessage.toLowerCase()
+
+  // Add your custom patterns
+  if (lowerMessage.includes('weather')) {
+    return '🌤️ The weather is great today!'
+  }
+
+  if (lowerMessage.includes('time')) {
+    return `🕐 Current time: ${new Date().toLocaleTimeString()}`
+  }
+
+  // Default response
+  return `💬 You said: "${userMessage}"`
+}
+```
+
+### Integrating AI/LLM Services
+
+For production use, integrate your preferred AI service:
+
+```typescript
+import OpenAI from 'openai'
+
+private async generateBotReply(userMessage: string): Promise<string> {
+  const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY })
+  
+  const completion = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [
+      { role: 'system', content: 'You are a helpful assistant.' },
+      { role: 'user', content: userMessage }
+    ]
+  })
+  
+  return completion.choices[0].message.content || 'Sorry, I could not generate a response.'
+}
+```
+
+### Message Flow
+
+```
+User (Web Dashboard)
+     │
+     ▼
+DashboardChannel ──execute_command──► BotChannel
+     │                                      │
+     │                                      ▼
+     │                              SDK receives command
+     │                                      │
+     │                                      ▼
+     │                              handleExecuteCommand()
+     │                                      │
+     │                                      ▼
+     │                              generateBotReply()
+     │                                      │
+     │                                      ▼
+     │◄───────── sendLog() ──────────sendLog('info', reply)
+     │
+     ▼
+Chat Controller displays message
+```
+
 ## License
 
 MIT © EyeClaw Team

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeclaw/eyeclaw",
-  "version": "2.0.0",
+  "version": "2.0.4",
   "description": "EyeClaw channel plugin for OpenClaw - Connect your local OpenClaw instance to EyeClaw platform",
   "type": "module",
   "main": "./index.ts",

package/src/channel.ts

@@ -178,6 +178,113 @@ export const eyeclawPlugin: ChannelPlugin<ResolvedEyeClawAccount> = {
       const client = new EyeClawClient(clientConfig, logger)
       clients.set(ctx.accountId, client)
       
+      // Register OpenClaw Agent callback for chat messages
+      client.setSendAgentCallback(async (message: string) => {
+        try {
+          ctx.log?.info(`🤖 Sending message to OpenClaw Agent: ${message}`)
+          
+          // Call OpenClaw Agent via spawn for streaming output
+          const { spawn } = await import('child_process')
+          
+          try {
+            // Spawn openclaw agent process for streaming output
+            const agentProcess = spawn('openclaw', [
+              'agent',
+              '--session-id', 'eyeclaw-web-chat',
+              '--message', message,
+              '--json'
+            ])
+            
+            let outputBuffer = ''
+            let streamId = Date.now().toString()
+            
+            // Send stream_start event
+            client.sendStreamChunk('stream_start', streamId, '')
+            
+            // Handle stdout (streaming response)
+            agentProcess.stdout?.on('data', (data: Buffer) => {
+              const text = data.toString()
+              outputBuffer += text
+              
+              // For streaming text output, send each chunk immediately
+              // Try to parse as JSON first
+              try {
+                const parsed = JSON.parse(outputBuffer)
+                // If we can parse the complete JSON, extract the text
+                const response = parsed.result?.payloads?.[0]?.text
+                if (response) {
+                  // Send the text in chunks
+                  const chunkSize = 50 // Send ~50 chars at a time
+                  for (let i = 0; i < response.length; i += chunkSize) {
+                    const chunk = response.substring(i, i + chunkSize)
+                    client.sendStreamChunk('stream_chunk', streamId, chunk)
+                  }
+                }
+                outputBuffer = '' // Clear buffer after successful parse
+              } catch (e) {
+                // Not valid JSON yet, check if we have complete lines to send
+                const lines = outputBuffer.split('\n')
+                // Keep last incomplete line in buffer
+                if (lines.length > 1) {
+                  for (let i = 0; i < lines.length - 1; i++) {
+                    if (lines[i].trim()) {
+                      client.sendStreamChunk('stream_chunk', streamId, lines[i] + '\n')
+                    }
+                  }
+                  outputBuffer = lines[lines.length - 1]
+                }
+              }
+            })
+            
+            // Handle stderr (errors)
+            agentProcess.stderr?.on('data', (data: Buffer) => {
+              const errorText = data.toString()
+              ctx.log?.error(`Agent stderr: ${errorText}`)
+            })
+            
+            // Handle process completion
+            agentProcess.on('close', (code: number) => {
+              // Send any remaining buffered content
+              if (outputBuffer.trim()) {
+                try {
+                  const parsed = JSON.parse(outputBuffer)
+                  const response = parsed.result?.payloads?.[0]?.text || outputBuffer.trim()
+                  client.sendStreamChunk('stream_chunk', streamId, response)
+                } catch (e) {
+                  client.sendStreamChunk('stream_chunk', streamId, outputBuffer.trim())
+                }
+              }
+              
+              // Send stream_end event
+              client.sendStreamChunk('stream_end', streamId, '')
+              
+              if (code === 0) {
+                ctx.log?.info(`✅ Agent completed successfully`)
+              } else {
+                ctx.log?.error(`Agent exited with code ${code}`)
+                client.sendLog('error', `❌ Agent error: process exited with code ${code}`)
+              }
+            })
+            
+            // Handle process errors
+            agentProcess.on('error', (error: Error) => {
+              ctx.log?.error(`Failed to start agent process: ${error.message}`)
+              client.sendStreamChunk('stream_error', streamId, error.message)
+              client.sendLog('error', `❌ Failed to start agent: ${error.message}`)
+            })
+            
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error)
+            ctx.log?.error(`Failed to execute openclaw agent: ${errorMsg}`)
+            client.sendLog('error', `❌ Agent error: ${errorMsg}`)
+          }
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error)
+          ctx.log?.error(`Failed to call OpenClaw Agent: ${errorMsg}`)
+          client.sendLog('error', `❌ Failed to call agent: ${errorMsg}`)
+        }
+      })
+      
       try {
         await client.connect()
         ctx.log?.info('✅ Successfully connected to EyeClaw platform')

package/src/client.ts

@@ -105,15 +105,105 @@ export class EyeClawClient {
         this.logger.info(`Command received by server: ${message.command}`)
         break
 
+      case 'execute_command':
+        this.handleExecuteCommand(message)
+        break
+
+      case 'ping':
+        this.logger.debug('Received ping from dashboard')
+        // Send pong response
+        this.sendLog('info', '🏓 Pong! Bot is alive.')
+        break
+
       case 'log':
         this.logger.info(`[Server Log] ${message.level}: ${message.message}`)
         break
 
+      case 'stream_chunk':
+        // Forward stream chunks to handler (will be handled by web UI)
+        const chunkPreview = typeof message.chunk === 'string' ? message.chunk.substring(0, 50) : String(message.chunk || '').substring(0, 50)
+        this.logger.debug(`Stream chunk: ${message.type} - ${chunkPreview}...`)
+        break
+
       default:
         this.logger.warn(`Unknown message type: ${type}`)
     }
   }
 
+  private handleExecuteCommand(message: Record<string, unknown>): void {
+    const command = message.command as string
+    const params = (message.params as Record<string, unknown>) || {}
+
+    this.logger.info(`📥 Executing command: ${command}`)
+
+    switch (command) {
+      case 'chat': {
+        const userMessage = params.message as string
+        this.logger.info(`💬 Chat message: ${userMessage}`)
+        
+        // Send user message acknowledgment
+        this.sendLog('info', `收到消息: ${userMessage}`)
+        
+        // Call OpenClaw Agent via callback
+        this.handleChatMessage(userMessage)
+        break
+      }
+
+      case 'ping': {
+        this.sendLog('info', '🏓 Pong! Bot is responding.')
+        break
+      }
+
+      case 'status': {
+        this.requestStatus()
+        break
+      }
+
+      case 'echo': {
+        const echoMessage = params.message as string
+        this.sendLog('info', `Echo: ${echoMessage}`)
+        break
+      }
+
+      case 'help': {
+        const helpMessage = [
+          '🤖 Available Commands:',
+          '• chat - Send a chat message',
+          '• ping - Test connection',
+          '• status - Get bot status',
+          '• echo - Echo a message',
+          '• help - Show this help',
+        ].join('\n')
+        this.sendLog('info', helpMessage)
+        break
+      }
+
+      default:
+        this.logger.warn(`Unknown command: ${command}`)
+        this.sendLog('error', `❌ Unknown command: ${command}`)
+    }
+  }
+
+  private handleChatMessage(userMessage: string): void {
+    // This will be called by OpenClaw channel plugin via sendAgent
+    if (this.sendAgentCallback) {
+      this.logger.info('🤖 Calling OpenClaw Agent...')
+      this.sendAgentCallback(userMessage)
+    } else {
+      // Fallback: simple echo if not running in OpenClaw context
+      this.logger.warn('No OpenClaw Agent available, using echo mode')
+      this.sendLog('info', `💬 Echo: "${userMessage}" (OpenClaw Agent not connected)`)
+    }
+  }
+
+  // Callback to send message to OpenClaw Agent (injected by channel plugin)
+  private sendAgentCallback: ((message: string) => Promise<void>) | null = null
+
+  setSendAgentCallback(callback: (message: string) => Promise<void>): void {
+    this.sendAgentCallback = callback
+    this.logger.info('✅ OpenClaw Agent callback registered')
+  }
+
   private handleStatusResponse(status: BotStatus): void {
     this.logger.info(`Bot status: online=${status.online}, status=${status.status}, sessions=${status.active_sessions}, uptime=${Math.floor(status.uptime / 60)}m`)
   }
@@ -190,6 +280,15 @@ export class EyeClawClient {
     })
   }
 
+  sendStreamChunk(type: string, streamId: string, chunk: string): void {
+    this.sendChannelMessage('stream_chunk', {
+      type,
+      stream_id: streamId,
+      chunk,
+      timestamp: new Date().toISOString(),
+    })
+  }
+
   sendCommandResult(command: string, result: unknown, error?: string): void {
     this.sendChannelMessage('command_result', {
       command,