@ynhcj/xiaoyi-channel 0.0.2 → 0.0.3-next

package/dist/src/websocket.js

@@ -10,6 +10,8 @@ import { sessionManager } from "./utils/session.js";
  *
  * Events:
  * - 'message': (message: A2AJsonRpcRequest, sessionId: string, serverId: ServerIdentifier) => void
+ * - 'data-event': (event: A2ADataEvent) => void
+ * - 'gui-agent-response': (event: any) => void
  * - 'connected': (serverId: ServerIdentifier) => void
  * - 'disconnected': (serverId: ServerIdentifier) => void
  * - 'error': (error: Error, serverId: ServerIdentifier) => void
@@ -40,6 +42,8 @@ export class XYWebSocketManager extends EventEmitter {
     // Logging functions following feishu pattern
     log;
     error;
+    // Health event callback
+    onHealthEvent;
     constructor(config, runtime) {
         super();
         this.config = config;
@@ -47,6 +51,12 @@ export class XYWebSocketManager extends EventEmitter {
         this.log = runtime?.log ?? console.log;
         this.error = runtime?.error ?? console.error;
     }
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     */
+    setHealthEventCallback(callback) {
+        this.onHealthEvent = callback;
+    }
     /**
      * Check if config matches the current instance.
      */
@@ -107,6 +117,7 @@ export class XYWebSocketManager extends EventEmitter {
      * Send a message to the appropriate server based on session binding.
      */
     async sendMessage(sessionId, message) {
+        console.log(`[WEBSOCKET-SEND] <<<<<<< Preparing to send message for session: ${sessionId} <<<<<<<`);
         // Determine which server to use
         let server = sessionManager.getBinding(sessionId);
         // If no binding, choose the first ready server
@@ -120,6 +131,10 @@ export class XYWebSocketManager extends EventEmitter {
             else {
                 throw new Error("No ready WebSocket servers available");
             }
+            console.log(`[WEBSOCKET-SEND] No binding found, selected: ${server}`);
+        }
+        else {
+            console.log(`[WEBSOCKET-SEND] Using bound server: ${server}`);
         }
         // Send to the selected server
         const ws = server === "server1" ? this.ws1 : this.ws2;
@@ -128,7 +143,9 @@ export class XYWebSocketManager extends EventEmitter {
             throw new Error(`WebSocket ${server} not ready`);
         }
         const messageStr = JSON.stringify(message);
+        console.log(`[WS-${server}-SEND] Sending message frame:`, JSON.stringify(message, null, 2));
         ws.send(messageStr);
+        console.log(`[WS-${server}-SEND] Message sent successfully, size: ${messageStr.length} bytes`);
     }
     /**
      * Check if at least one server is ready.
@@ -136,19 +153,98 @@ export class XYWebSocketManager extends EventEmitter {
     isReady() {
         return this.state1.ready || this.state2.ready;
     }
+    /**
+     * Get detailed connection diagnostics for monitoring and debugging.
+     * Helps identify orphan connections and connection leaks.
+     */
+    getConnectionDiagnostics() {
+        const cacheKey = `${this.config.apiKey}-${this.config.agentId}`;
+        const server1Diag = this.getServerDiagnostic("server1", this.ws1, this.state1, this.heartbeat1, this.reconnectTimer1);
+        const server2Diag = this.getServerDiagnostic("server2", this.ws2, this.state2, this.heartbeat2, this.reconnectTimer2);
+        // Count total event listeners on the manager
+        const totalEventListeners = this.listenerCount('message') +
+            this.listenerCount('connected') +
+            this.listenerCount('disconnected') +
+            this.listenerCount('error') +
+            this.listenerCount('ready') +
+            this.listenerCount('data-event') +
+            this.listenerCount('gui-agent-response');
+        return {
+            cacheKey,
+            server1: server1Diag,
+            server2: server2Diag,
+            isShuttingDown: this.isShuttingDown,
+            totalEventListeners,
+        };
+    }
+    /**
+     * Get diagnostic info for a single server connection.
+     */
+    getServerDiagnostic(serverId, ws, state, heartbeat, reconnectTimer) {
+        const exists = ws !== null;
+        let readyState = 'NULL';
+        let listenerCount = 0;
+        if (ws) {
+            switch (ws.readyState) {
+                case WebSocket.CONNECTING:
+                    readyState = 'CONNECTING';
+                    break;
+                case WebSocket.OPEN:
+                    readyState = 'OPEN';
+                    break;
+                case WebSocket.CLOSING:
+                    readyState = 'CLOSING';
+                    break;
+                case WebSocket.CLOSED:
+                    readyState = 'CLOSED';
+                    break;
+            }
+            // Count event listeners on the WebSocket
+            listenerCount = ws.listenerCount('message') +
+                ws.listenerCount('close') +
+                ws.listenerCount('error') +
+                ws.listenerCount('open') +
+                ws.listenerCount('pong');
+        }
+        // Orphan detection: connection is OPEN but has no message listeners
+        const isOrphan = exists &&
+            ws.readyState === WebSocket.OPEN &&
+            ws.listenerCount('message') === 0;
+        return {
+            exists,
+            readyState,
+            stateConnected: state.connected,
+            stateReady: state.ready,
+            reconnectAttempts: state.reconnectAttempts,
+            lastHeartbeat: state.lastHeartbeat,
+            heartbeatActive: heartbeat !== null,
+            hasReconnectTimer: reconnectTimer !== null,
+            listenerCount,
+            isOrphan,
+        };
+    }
     /**
      * Connect to a specific server.
      */
     async connectServer(serverId, url) {
         return new Promise((resolve, reject) => {
-            const ws = new WebSocket(url, {
+            // Check if URL is wss with IP address to bypass certificate validation
+            const urlObj = new URL(url);
+            const isWssWithIP = urlObj.protocol === 'wss:' && /^(\d{1,3}\.){3}\d{1,3}$/.test(urlObj.hostname);
+            const wsOptions = {
                 headers: {
                     "x-uid": this.config.uid,
                     "x-api-key": this.config.apiKey,
                     "x-agent-id": this.config.agentId,
                     "x-request-from": "openclaw",
                 },
-            });
+            };
+            // Bypass certificate validation for wss with IP address
+            if (isWssWithIP) {
+                this.log(`${serverId}: Bypassing certificate validation for IP address: ${urlObj.hostname}`);
+                wsOptions.rejectUnauthorized = false;
+            }
+            const ws = new WebSocket(url, wsOptions);
             const state = serverId === "server1" ? this.state1 : this.state2;
             // Set the WebSocket instance
             if (serverId === "server1") {
@@ -234,7 +330,10 @@ export class XYWebSocketManager extends EventEmitter {
             agentId: this.config.agentId,
             msgDetail: JSON.stringify({ agentId: this.config.agentId }),
         };
-        ws.send(JSON.stringify(initMessage));
+        const initMessageStr = JSON.stringify(initMessage);
+        console.log(`[WS-${serverId}-SEND] Sending init message frame:`, JSON.stringify(initMessage, null, 2));
+        ws.send(initMessageStr);
+        console.log(`[WS-${serverId}-SEND] Init message sent successfully, size: ${initMessageStr.length} bytes`);
         // Mark as ready after init
         const state = serverId === "server1" ? this.state1 : this.state2;
         state.ready = true;
@@ -260,7 +359,8 @@ export class XYWebSocketManager extends EventEmitter {
         }, () => {
             this.error(`Heartbeat timeout for ${serverId}, reconnecting...`);
             this.reconnectServer(serverId);
-        }, serverId, this.log, this.error);
+        }, serverId, this.log, this.error, this.onHealthEvent // ✅ Pass health event callback
+        );
         heartbeat.start();
         if (serverId === "server1") {
             this.heartbeat1 = heartbeat;
@@ -273,11 +373,13 @@ export class XYWebSocketManager extends EventEmitter {
      * Handle incoming message from server.
      */
     handleMessage(serverId, data) {
+        console.log(`[WEBSOCKET-HANDLE] >>>>>>> serverId: ${serverId}, receiving message... <<<<<<<`);
         try {
             const messageStr = data.toString();
+            console.log(`[WS-${serverId}-RECV] Raw message frame, size: ${messageStr.length} bytes`);
             const parsed = JSON.parse(messageStr);
             // Log raw message
-            console.log(`[XY-${serverId}] Received message:`, JSON.stringify(parsed, null, 2));
+            console.log(`[WS-${serverId}-RECV] Parsed message:`, JSON.stringify(parsed, null, 2));
             // Check if message is in direct A2A JSON-RPC format (server push)
             if (parsed.jsonrpc === "2.0") {
                 // Direct A2A format
@@ -295,16 +397,96 @@ export class XYWebSocketManager extends EventEmitter {
                     sessionManager.bind(sessionId, serverId);
                     console.log(`[XY-${serverId}] Bound session ${sessionId} to ${serverId}`);
                 }
-                // Emit message event
+                // Check if message contains only data parts (tool results)
+                const dataParts = a2aRequest.params?.message?.parts?.filter((p) => p.kind === "data");
+                const hasOnlyDataParts = dataParts && dataParts.length > 0 &&
+                    dataParts.length === a2aRequest.params?.message?.parts?.length;
+                if (hasOnlyDataParts) {
+                    // This is a data-only message (e.g., intent execution result)
+                    // Only emit data-event, don't send to openclaw
+                    console.log(`[XY-${serverId}] Message contains only data parts, processing as tool result`);
+                    for (const dataPart of dataParts) {
+                        // Data format: {events: [{header, payload}, ...]}
+                        const events = dataPart.data?.events;
+                        if (!Array.isArray(events)) {
+                            console.warn(`[XY-${serverId}] dataPart.data.events is not an array, skipping`);
+                            continue;
+                        }
+                        console.log(`[XY-${serverId}] Processing ${events.length} events from data.events`);
+                        for (const item of events) {
+                            // Check if it's an UploadExeResult (intent execution result)
+                            if (item.header?.name === "UploadExeResult" && item.payload?.intentName) {
+                                const dataEvent = {
+                                    intentName: item.payload.intentName,
+                                    outputs: item.payload.outputs || {},
+                                    status: "success",
+                                };
+                                console.log(`[XY-${serverId}] Emitting data-event:`, dataEvent);
+                                this.emit("data-event", dataEvent);
+                            }
+                            // Check if it's an InvokeJarvisGUIAgentResponse
+                            else if (item.header?.namespace === "ClawAgent" && item.header?.name === "InvokeJarvisGUIAgentResponse") {
+                                console.log(`[XY-${serverId}] Emitting gui-agent-response:`, item);
+                                this.emit("gui-agent-response", item);
+                            }
+                        }
+                    }
+                    return; // Don't emit message event
+                }
+                // Emit message event for non-data-only messages
+                console.log(`[XY-${serverId}] *** EMITTING message event (Direct A2A path) ***`);
                 this.emit("message", a2aRequest, sessionId, serverId);
                 return;
             }
             // Wrapped format (InboundWebSocketMessage)
             const inboundMsg = parsed;
             console.log(`[XY-${serverId}] Message type: Wrapped, msgType: ${inboundMsg.msgType}`);
-            // Skip heartbeat responses
-            if (inboundMsg.msgType === "heartbeat" || inboundMsg.msgType === "data") {
-                console.log(`[XY-${serverId}] Skipping ${inboundMsg.msgType} message`);
+            // Handle heartbeat responses
+            if (inboundMsg.msgType === "heartbeat") {
+                console.log(`[XY-${serverId}] Received heartbeat response`);
+                // ✅ Report health: application-level heartbeat received
+                // This prevents openclaw health-monitor from marking connection as stale
+                this.onHealthEvent?.();
+                return;
+            }
+            // Handle data messages (e.g., intent execution results)
+            if (inboundMsg.msgType === "data") {
+                console.log(`[XY-${serverId}] Processing data message`);
+                try {
+                    const a2aRequest = JSON.parse(inboundMsg.msgDetail);
+                    const dataParts = a2aRequest.params?.message?.parts?.filter((p) => p.kind === "data");
+                    if (dataParts && dataParts.length > 0) {
+                        for (const dataPart of dataParts) {
+                            // Data format: {events: [{header, payload}, ...]}
+                            const events = dataPart.data?.events;
+                            if (!Array.isArray(events)) {
+                                console.warn(`[XY-${serverId}] dataPart.data.events is not an array, skipping`);
+                                continue;
+                            }
+                            console.log(`[XY-${serverId}] Processing ${events.length} events from data.events`);
+                            for (const item of events) {
+                                // Check if it's an UploadExeResult (intent execution result)
+                                if (item.header?.name === "UploadExeResult" && item.payload?.intentName) {
+                                    const dataEvent = {
+                                        intentName: item.payload.intentName,
+                                        outputs: item.payload.outputs || {},
+                                        status: "success",
+                                    };
+                                    console.log(`[XY-${serverId}] Emitting data-event:`, dataEvent);
+                                    this.emit("data-event", dataEvent);
+                                }
+                                // Check if it's an InvokeJarvisGUIAgentResponse
+                                else if (item.header?.namespace === "ClawAgent" && item.header?.name === "InvokeJarvisGUIAgentResponse") {
+                                    console.log(`[XY-${serverId}] Emitting gui-agent-response:`, item);
+                                    this.emit("gui-agent-response", item);
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`[XY-${serverId}] Failed to process data message:`, error);
+                }
                 return;
             }
             // Parse msgDetail as A2AJsonRpcRequest
@@ -318,6 +500,7 @@ export class XYWebSocketManager extends EventEmitter {
             }
             console.log(`[XY-${serverId}] Session ID: ${sessionId}`);
             // Emit message event
+            console.log(`[XY-${serverId}] *** EMITTING message event (Wrapped path) ***`);
             this.emit("message", a2aRequest, sessionId, serverId);
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.2",
+  "version": "0.0.3-next",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",
@@ -62,7 +62,6 @@
     "node-fetch": "^2.7.0"
   },
   "devDependencies": {
-    "openclaw": ">=2026.3.1",
     "@types/ws": "^8.5.8",
     "@types/uuid": "^9.0.5",
     "@types/node": "^20.8.0",