@eyeclaw/eyeclaw 1.0.5 → 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/index.ts

@@ -1,9 +1,6 @@
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
 import { emptyPluginConfigSchema } from 'openclaw/plugin-sdk'
-import { EyeClawClient } from './src/client.js'
-import type { PluginConfig } from './src/types.js'
-
-let client: EyeClawClient | null = null
+import { eyeclawPlugin } from './src/channel.js'
 
 /**
  * EyeClaw SDK - OpenClaw Channel Plugin
@@ -17,94 +14,8 @@ const plugin = {
   configSchema: emptyPluginConfigSchema(),
   
   register(api: OpenClawPluginApi) {
-    const runtime = api.runtime
-    const logger = runtime.logging.getChildLogger({ plugin: 'eyeclaw' })
-    
-    // Try multiple ways to access config
-    const runtimeConfig = runtime.config as any
-    const apiConfig = (api as any).config
-    const pluginConfig = (api as any).pluginConfig
-    
-    // Debug: log entire config structure from different sources
-    logger.info('🔍 runtime.config:', JSON.stringify(runtimeConfig, null, 2))
-    logger.info('🔍 api.config:', JSON.stringify(apiConfig, null, 2))
-    logger.info('🔍 api.pluginConfig:', JSON.stringify(pluginConfig, null, 2))
-    logger.info('🔍 api keys:', Object.keys(api).join(', '))
-    logger.info('🔍 runtime keys:', Object.keys(runtime).join(', '))
-    
-    // Try to get config from different sources
-    let eyeclawConfig: PluginConfig = 
-      pluginConfig || 
-      apiConfig || 
-      runtimeConfig?.channels?.eyeclaw || 
-      runtimeConfig?.plugins?.eyeclaw || 
-      {}
-    
-    // Debug: log eyeclaw config
-    logger.info('🔍 EyeClaw config:', JSON.stringify(eyeclawConfig, null, 2))
-    logger.info('🔍 botId type:', typeof eyeclawConfig.botId)
-    logger.info('🔍 botId value:', eyeclawConfig.botId)
-    logger.info('🔍 sdkToken type:', typeof eyeclawConfig.sdkToken)
-    logger.info('🔍 sdkToken exists:', !!eyeclawConfig.sdkToken)
-    
-    // Check if enabled
-    if (eyeclawConfig.enabled === false) {
-      logger.info('Plugin disabled in config')
-      return
-    }
-    
-    // Validate required fields with detailed logging
-    if (!eyeclawConfig.botId) {
-      logger.warn('❌ botId is missing or falsy:', eyeclawConfig.botId)
-      logger.warn('Configure with: openclaw config set channels.eyeclaw.botId "YOUR_BOT_ID"')
-      return
-    }
-    
-    if (!eyeclawConfig.sdkToken) {
-      logger.warn('❌ sdkToken is missing or falsy')
-      logger.warn('Configure with: openclaw config set channels.eyeclaw.sdkToken "YOUR_SDK_TOKEN"')
-      return
-    }
-    
-    logger.info('✅ Config validation passed')
-    
-    // Convert botId to string (OpenClaw may auto-convert "1" to number 1)
-    eyeclawConfig.botId = String(eyeclawConfig.botId)
-    
-    // Set defaults
-    eyeclawConfig.serverUrl = eyeclawConfig.serverUrl || 'http://localhost:3000'
-    eyeclawConfig.reconnectInterval = eyeclawConfig.reconnectInterval || 5000
-    eyeclawConfig.heartbeatInterval = eyeclawConfig.heartbeatInterval || 30000
-    
-    logger.info('🦞 Starting EyeClaw SDK...', { botId: eyeclawConfig.botId, serverUrl: eyeclawConfig.serverUrl })
-    
-    // Create logger adapter for client (simple console logger)
-    const clientLogger = {
-      debug: (msg: string) => logger.debug(msg),
-      info: (msg: string) => logger.info(msg),
-      warn: (msg: string) => logger.warn(msg),
-      error: (msg: string) => logger.error(msg),
-    }
-    
-    // Create and connect WebSocket client
-    client = new EyeClawClient(eyeclawConfig, clientLogger)
-    
-    client.connect().then(() => {
-      logger.info('✅ Successfully connected to EyeClaw platform')
-    }).catch((error: Error) => {
-      logger.error('Failed to connect to EyeClaw', { error: error.message })
-    })
-    
-    // Handle shutdown
-    const shutdown = () => {
-      if (client) {
-        logger.info('🛑 Shutting down EyeClaw SDK...')
-        client.disconnect()
-      }
-    }
-    
-    process.on('SIGINT', shutdown)
-    process.on('SIGTERM', shutdown)
+    // Register EyeClaw as a channel plugin
+    api.registerChannel({ plugin: eyeclawPlugin })
   },
 }
 
@@ -113,3 +24,4 @@ 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'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eyeclaw/eyeclaw",
-  "version": "1.0.5",
+  "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

@@ -0,0 +1,253 @@
+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>()
+
+/**
+ * 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) => {
+      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),
+      }
+      
+      // Create and connect client
+      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')
+        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
+      }
+    },
+  },
+}

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`)
   }

package/src/types.ts

@@ -1,5 +1,21 @@
-// Type definitions for OpenClaw plugin system
-// Reference: clawdbot-feishu architecture
+// Type definitions for EyeClaw Channel 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