@eyeclaw/eyeclaw 2.0.0 → 2.0.2

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.2",
   "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,50 @@ 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 CLI (since ctx.sendAgent doesn't exist)
+          const { spawn } = await import('child_process')
+          const { promisify } = await import('util')
+          const exec = promisify((await import('child_process')).exec)
+          
+          try {
+            // Call openclaw agent CLI to process the message
+            const result = await exec(
+              `openclaw agent --session-id eyeclaw-web-chat --message ${JSON.stringify(message)} --json`,
+              { timeout: 60000 }
+            )
+            
+            if (result.stdout) {
+              try {
+                const parsed = JSON.parse(result.stdout)
+                // OpenClaw CLI returns: { result: { payloads: [{ text: "...", mediaUrl: null }] } }
+                const response = parsed.result?.payloads?.[0]?.text || 'Agent completed (no text)'
+                ctx.log?.info(`✅ Agent response: ${response.substring(0, 100)}...`)
+                client.sendLog('info', response)
+              } catch (e) {
+                // If not JSON, just send the stdout
+                ctx.log?.info(`✅ Agent response (raw): ${result.stdout.substring(0, 100)}...`)
+                client.sendLog('info', result.stdout.trim())
+              }
+            } else {
+              client.sendLog('info', '✅ Agent completed successfully')
+            }
+          } 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,6 +105,16 @@ 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
@@ -114,6 +124,80 @@ export class EyeClawClient {
     }
   }
 
+  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`)
   }