@ynhcj/xiaoyi-channel 0.0.9 → 0.0.11-beta

package/dist/src/utils/config-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+declare class ConfigManager {
+    private sessionPushIds;
+    private globalPushId;
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId: string, pushId: string): void;
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId?: string): string | null;
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * Clear all cached push IDs.
+     */
+    clear(): void;
+}
+export declare const configManager: ConfigManager;
+export {};

package/dist/src/utils/config-manager.js

@@ -0,0 +1,56 @@
+// Dynamic configuration manager for runtime updates
+import { logger } from "./logger.js";
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+class ConfigManager {
+    sessionPushIds = new Map();
+    globalPushId = null;
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId, pushId) {
+        if (!pushId) {
+            logger.warn(`[ConfigManager] Attempted to set empty pushId for session ${sessionId}`);
+            return;
+        }
+        const previous = this.sessionPushIds.get(sessionId);
+        if (previous !== pushId) {
+            logger.log(`[ConfigManager] ✨ Updated pushId for session ${sessionId}`);
+            logger.log(`[ConfigManager]   - Previous: ${previous ? previous.substring(0, 20) + '...' : 'none'}`);
+            logger.log(`[ConfigManager]   - New:      ${pushId.substring(0, 20)}...`);
+            logger.log(`[ConfigManager]   - Full new pushId: ${pushId}`);
+            this.sessionPushIds.set(sessionId, pushId);
+            this.globalPushId = pushId; // Also update global for backward compatibility
+        }
+    }
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId) {
+        if (sessionId) {
+            const sessionPushId = this.sessionPushIds.get(sessionId);
+            if (sessionPushId) {
+                return sessionPushId;
+            }
+        }
+        return this.globalPushId;
+    }
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId) {
+        this.sessionPushIds.delete(sessionId);
+        logger.debug(`[ConfigManager] Cleared pushId for session ${sessionId}`);
+    }
+    /**
+     * Clear all cached push IDs.
+     */
+    clear() {
+        this.sessionPushIds.clear();
+        this.globalPushId = null;
+        logger.debug(`[ConfigManager] Cleared all cached pushIds`);
+    }
+}
+export const configManager = new ConfigManager();

package/dist/src/websocket.d.ts

@@ -1,6 +1,31 @@
 import { EventEmitter } from "events";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
 import type { XYChannelConfig, OutboundWebSocketMessage } from "./types.js";
+/**
+ * Diagnostics for a single WebSocket connection
+ */
+export interface ConnectionDiagnostic {
+    exists: boolean;
+    readyState: string;
+    stateConnected: boolean;
+    stateReady: boolean;
+    reconnectAttempts: number;
+    lastHeartbeat: number;
+    heartbeatActive: boolean;
+    hasReconnectTimer: boolean;
+    listenerCount: number;
+    isOrphan: boolean;
+}
+/**
+ * Full diagnostics for WebSocket manager
+ */
+export interface ManagerDiagnostics {
+    cacheKey: string;
+    server1: ConnectionDiagnostic;
+    server2: ConnectionDiagnostic;
+    isShuttingDown: boolean;
+    totalEventListeners: number;
+}
 /**
  * Manages dual WebSocket connections to XY servers.
  * Implements session-to-server binding for message routing.
@@ -27,7 +52,12 @@ export declare class XYWebSocketManager extends EventEmitter {
     private isShuttingDown;
     private log;
     private error;
+    private onHealthEvent?;
     constructor(config: XYChannelConfig, runtime?: RuntimeEnv);
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     */
+    setHealthEventCallback(callback: () => void): void;
     /**
      * Check if config matches the current instance.
      */
@@ -49,6 +79,15 @@ export declare class XYWebSocketManager extends EventEmitter {
      * Check if at least one server is ready.
      */
     isReady(): boolean;
+    /**
+     * Get detailed connection diagnostics for monitoring and debugging.
+     * Helps identify orphan connections and connection leaks.
+     */
+    getConnectionDiagnostics(): ManagerDiagnostics;
+    /**
+     * Get diagnostic info for a single server connection.
+     */
+    private getServerDiagnostic;
     /**
      * Connect to a specific server.
      */

package/dist/src/websocket.js

@@ -41,6 +41,8 @@ export class XYWebSocketManager extends EventEmitter {
     // Logging functions following feishu pattern
     log;
     error;
+    // Health event callback
+    onHealthEvent;
     constructor(config, runtime) {
         super();
         this.config = config;
@@ -48,6 +50,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.
      */
@@ -144,19 +152,97 @@ 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');
+        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") {
@@ -271,7 +357,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;
@@ -317,19 +404,23 @@ export class XYWebSocketManager extends EventEmitter {
                     // 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) {
-                        const dataArray = dataPart.data;
-                        if (Array.isArray(dataArray)) {
-                            for (const item of dataArray) {
-                                // 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);
-                                }
+                        // 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);
                             }
                         }
                     }
@@ -343,9 +434,12 @@ export class XYWebSocketManager extends EventEmitter {
             // Wrapped format (InboundWebSocketMessage)
             const inboundMsg = parsed;
             console.log(`[XY-${serverId}] Message type: Wrapped, msgType: ${inboundMsg.msgType}`);
-            // Skip heartbeat responses
+            // Handle heartbeat responses
             if (inboundMsg.msgType === "heartbeat") {
-                console.log(`[XY-${serverId}] Skipping ${inboundMsg.msgType} message`);
+                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)
@@ -356,19 +450,23 @@ export class XYWebSocketManager extends EventEmitter {
                     const dataParts = a2aRequest.params?.message?.parts?.filter((p) => p.kind === "data");
                     if (dataParts && dataParts.length > 0) {
                         for (const dataPart of dataParts) {
-                            const dataArray = dataPart.data;
-                            if (Array.isArray(dataArray)) {
-                                for (const item of dataArray) {
-                                    // 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);
-                                    }
+                            // 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);
                                 }
                             }
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi-channel",
-  "version": "0.0.9",
+  "version": "0.0.11-beta",
   "description": "OpenClaw Xiaoyi Channel plugin - Xiaoyi A2A protocol integration",
   "type": "module",
   "main": "./dist/index.js",