@eyeclaw/eyeclaw 1.0.5 → 2.0.0

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.0",
   "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,209 @@
+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)
+      
+      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/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