@ynhcj/xiaoyi 2.5.5 → 2.5.7

package/dist/websocket.js

@@ -7,8 +7,9 @@ exports.XiaoYiWebSocketManager = void 0;
 const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const url_1 = require("url");
-const auth_1 = require("./auth");
-const types_1 = require("./types");
+const auth_js_1 = require("./auth.js");
+const heartbeat_js_1 = require("./heartbeat.js");
+const types_js_1 = require("./types.js");
 class XiaoYiWebSocketManager extends events_1.EventEmitter {
     constructor(config) {
         super();
@@ -30,15 +31,26 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         };
         // ==================== Session → Server Mapping ====================
         this.sessionServerMap = new Map();
+        // ==================== Session Cleanup State ====================
+        // Track sessions that are pending cleanup (user cleared context but task still running)
+        this.sessionCleanupStateMap = new Map();
         // ==================== Active Tasks ====================
         this.activeTasks = new Map();
         // Resolve configuration with defaults and backward compatibility
         this.config = this.resolveConfig(config);
-        this.auth = new auth_1.XiaoYiAuth(this.config.ak, this.config.sk, this.config.agentId);
+        this.auth = new auth_js_1.XiaoYiAuth(this.config.ak, this.config.sk, this.config.agentId);
         console.log(`[WS Manager] Initialized with dual server:`);
         console.log(`  Server 1: ${this.config.wsUrl1}`);
         console.log(`  Server 2: ${this.config.wsUrl2}`);
     }
+    /**
+     * Set health event callback to report activity to OpenClaw framework.
+     * This callback is invoked on heartbeat success to update lastEventAt.
+     */
+    setHealthEventCallback(callback) {
+        this.onHealthEvent = callback;
+        console.log("[WS Manager] Health event callback registered");
+    }
     /**
      * Check if URL is wss + IP format (skip certificate verification)
      */
@@ -93,12 +105,12 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }
         // Apply defaults if not provided
         if (!wsUrl1) {
-            console.warn(`[WS Manager] wsUrl1 not provided, using default: ${types_1.DEFAULT_WS_URL_1}`);
-            wsUrl1 = types_1.DEFAULT_WS_URL_1;
+            console.warn(`[WS Manager] wsUrl1 not provided, using default: ${types_js_1.DEFAULT_WS_URL_1}`);
+            wsUrl1 = types_js_1.DEFAULT_WS_URL_1;
         }
         if (!wsUrl2) {
-            console.warn(`[WS Manager] wsUrl2 not provided, using default: ${types_1.DEFAULT_WS_URL_2}`);
-            wsUrl2 = types_1.DEFAULT_WS_URL_2;
+            console.warn(`[WS Manager] wsUrl2 not provided, using default: ${types_js_1.DEFAULT_WS_URL_2}`);
+            wsUrl2 = types_js_1.DEFAULT_WS_URL_2;
         }
         return {
             wsUrl1,
@@ -107,6 +119,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             ak: userConfig.ak,
             sk: userConfig.sk,
             enableStreaming: userConfig.enableStreaming ?? true,
+            sessionCleanupTimeoutMs: userConfig.sessionCleanupTimeoutMs ?? XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS,
         };
     }
     /**
@@ -137,6 +150,22 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     async connectToServer1() {
         console.log(`[Server1] Connecting to ${this.config.wsUrl1}...`);
         try {
+            // ✅ Close existing connection and heartbeat before creating new one
+            if (this.ws1) {
+                console.log(`[Server1] Closing existing connection before reconnect`);
+                if (this.heartbeat1) {
+                    this.heartbeat1.stop();
+                    this.heartbeat1 = undefined;
+                }
+                try {
+                    this.ws1.removeAllListeners();
+                    this.ws1.close();
+                }
+                catch (err) {
+                    console.warn(`[Server1] Error closing old connection:`, err);
+                }
+                this.ws1 = null;
+            }
             const authHeaders = this.auth.generateAuthHeaders();
             // Check if URL is wss + IP format, skip certificate verification
             const skipCertVerify = this.isWssWithIp(this.config.wsUrl1);
@@ -147,6 +176,26 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 headers: authHeaders,
                 rejectUnauthorized: !skipCertVerify,
             });
+            // ✅ Initialize HeartbeatManager for server1
+            this.heartbeat1 = new heartbeat_js_1.HeartbeatManager(this.ws1, {
+                interval: 30000, // 30 seconds
+                timeout: 10000, // 10 seconds timeout
+                message: JSON.stringify({
+                    msgType: "heartbeat",
+                    agentId: this.config.agentId,
+                    timestamp: Date.now(),
+                }),
+            }, () => {
+                console.log(`[Server1] Heartbeat timeout, reconnecting...`);
+                if (this.ws1 && (this.ws1.readyState === ws_1.default.OPEN || this.ws1.readyState === ws_1.default.CONNECTING)) {
+                    this.ws1.close();
+                }
+            }, "server1", console.log, console.error, () => {
+                // ✅ Heartbeat success callback - report health to OpenClaw
+                this.emit("heartbeat", "server1");
+                // ✅ Report liveness to OpenClaw framework to prevent stale-socket detection
+                this.onHealthEvent?.();
+            });
             this.setupWebSocketHandlers(this.ws1, 'server1');
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
@@ -167,8 +216,9 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             this.scheduleStableConnectionCheck('server1');
             // Send init message
             this.sendInitMessage(this.ws1, 'server1');
-            // Start protocol heartbeat
-            this.startProtocolHeartbeat('server1');
+            // ✅ Start heartbeat (replaces old startProtocolHeartbeat)
+            this.heartbeat1.start();
+            console.log(`[Server1] Heartbeat started (30s interval, 10s timeout)`);
         }
         catch (error) {
             console.error(`[Server1] Connection failed:`, error);
@@ -184,6 +234,22 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     async connectToServer2() {
         console.log(`[Server2] Connecting to ${this.config.wsUrl2}...`);
         try {
+            // ✅ Close existing connection and heartbeat before creating new one
+            if (this.ws2) {
+                console.log(`[Server2] Closing existing connection before reconnect`);
+                if (this.heartbeat2) {
+                    this.heartbeat2.stop();
+                    this.heartbeat2 = undefined;
+                }
+                try {
+                    this.ws2.removeAllListeners();
+                    this.ws2.close();
+                }
+                catch (err) {
+                    console.warn(`[Server2] Error closing old connection:`, err);
+                }
+                this.ws2 = null;
+            }
             const authHeaders = this.auth.generateAuthHeaders();
             // Check if URL is wss + IP format, skip certificate verification
             const skipCertVerify = this.isWssWithIp(this.config.wsUrl2);
@@ -194,6 +260,26 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 headers: authHeaders,
                 rejectUnauthorized: !skipCertVerify,
             });
+            // ✅ Initialize HeartbeatManager for server2
+            this.heartbeat2 = new heartbeat_js_1.HeartbeatManager(this.ws2, {
+                interval: 30000, // 30 seconds
+                timeout: 10000, // 10 seconds timeout
+                message: JSON.stringify({
+                    msgType: "heartbeat",
+                    agentId: this.config.agentId,
+                    timestamp: Date.now(),
+                }),
+            }, () => {
+                console.log(`[Server2] Heartbeat timeout, reconnecting...`);
+                if (this.ws2 && (this.ws2.readyState === ws_1.default.OPEN || this.ws2.readyState === ws_1.default.CONNECTING)) {
+                    this.ws2.close();
+                }
+            }, "server2", console.log, console.error, () => {
+                // ✅ Heartbeat success callback - report health to OpenClaw
+                this.emit("heartbeat", "server2");
+                // ✅ Report liveness to OpenClaw framework to prevent stale-socket detection
+                this.onHealthEvent?.();
+            });
             this.setupWebSocketHandlers(this.ws2, 'server2');
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
@@ -214,8 +300,9 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             this.scheduleStableConnectionCheck('server2');
             // Send init message
             this.sendInitMessage(this.ws2, 'server2');
-            // Start protocol heartbeat
-            this.startProtocolHeartbeat('server2');
+            // ✅ Start heartbeat (replaces old startProtocolHeartbeat)
+            this.heartbeat2.start();
+            console.log(`[Server2] Heartbeat started (30s interval, 10s timeout)`);
         }
         catch (error) {
             console.error(`[Server2] Connection failed:`, error);
@@ -231,12 +318,42 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     disconnect() {
         console.log("[WS Manager] Disconnecting from all servers...");
         this.clearTimers();
+        // ✅ Stop heartbeat managers
+        if (this.heartbeat1) {
+            console.log("[Server1] Stopping heartbeat manager");
+            this.heartbeat1.stop();
+            this.heartbeat1 = undefined;
+        }
+        if (this.heartbeat2) {
+            console.log("[Server2] Stopping heartbeat manager");
+            this.heartbeat2.stop();
+            this.heartbeat2 = undefined;
+        }
+        // ✅ Properly cleanup WebSocket connections to prevent ghost connections
         if (this.ws1) {
-            this.ws1.close();
+            try {
+                console.log("[Server1] Removing all listeners and closing connection");
+                this.ws1.removeAllListeners();
+                if (this.ws1.readyState === ws_1.default.OPEN || this.ws1.readyState === ws_1.default.CONNECTING) {
+                    this.ws1.close();
+                }
+            }
+            catch (err) {
+                console.warn("[Server1] Error during disconnect:", err);
+            }
             this.ws1 = null;
         }
         if (this.ws2) {
-            this.ws2.close();
+            try {
+                console.log("[Server2] Removing all listeners and closing connection");
+                this.ws2.removeAllListeners();
+                if (this.ws2.readyState === ws_1.default.OPEN || this.ws2.readyState === ws_1.default.CONNECTING) {
+                    this.ws2.close();
+                }
+            }
+            catch (err) {
+                console.warn("[Server2] Error during disconnect:", err);
+            }
             this.ws2 = null;
         }
         this.state1.connected = false;
@@ -245,7 +362,15 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         this.state2.ready = false;
         this.sessionServerMap.clear();
         this.activeTasks.clear();
+        // Cleanup session cleanup state map
+        for (const [sessionId, state] of this.sessionCleanupStateMap.entries()) {
+            if (state.cleanupTimeoutId) {
+                clearTimeout(state.cleanupTimeoutId);
+            }
+        }
+        this.sessionCleanupStateMap.clear();
         this.emit("disconnected");
+        console.log("[WS Manager] Disconnect complete");
     }
     /**
      * Send init message to specific server
@@ -382,7 +507,14 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     /**
      * Send A2A response message with automatic routing
      */
-    async sendResponse(response, taskId, sessionId, isFinal = true, append = false) {
+    async sendResponse(response, taskId, sessionId, isFinal = true, append = true) {
+        // Check if session is pending cleanup
+        const cleanupState = this.sessionCleanupStateMap.get(sessionId);
+        if (cleanupState) {
+            // Session is pending cleanup, silently discard response
+            console.log(`[RESPONSE] Discarding response for pending cleanup session ${sessionId}`);
+            return;
+        }
         // Find which server this session belongs to
         const targetServer = this.sessionServerMap.get(sessionId);
         if (!targetServer) {
@@ -461,6 +593,13 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
      * This uses "status-update" event type which keeps the conversation active
      */
     async sendStatusUpdate(taskId, sessionId, message, targetServer) {
+        // Check if session is pending cleanup
+        const cleanupState = this.sessionCleanupStateMap.get(sessionId);
+        if (cleanupState) {
+            // Session is pending cleanup, silently discard status updates
+            console.log(`[STATUS] Discarding status update for pending cleanup session ${sessionId}`);
+            return;
+        }
         const serverId = targetServer || this.sessionServerMap.get(sessionId);
         if (!serverId) {
             console.error(`[STATUS] Unknown server for session ${sessionId}`);
@@ -535,6 +674,42 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         // TODO: Implement actual push message sending via HTTP API
         // Need to confirm correct push message format with XiaoYi API documentation
     }
+    /**
+     * Send an outbound WebSocket message directly.
+     * This is a low-level method that sends a pre-formatted OutboundWebSocketMessage.
+     *
+     * @param sessionId - Session ID for routing
+     * @param message - Pre-formatted outbound message
+     */
+    async sendMessage(sessionId, message) {
+        // Check if session is pending cleanup
+        const cleanupState = this.sessionCleanupStateMap.get(sessionId);
+        if (cleanupState) {
+            console.log(`[SEND_MESSAGE] Discarding message for pending cleanup session ${sessionId}`);
+            return;
+        }
+        // Find which server this session belongs to
+        const targetServer = this.sessionServerMap.get(sessionId);
+        if (!targetServer) {
+            console.error(`[SEND_MESSAGE] Unknown server for session ${sessionId}`);
+            throw new Error(`Cannot route message: unknown session ${sessionId}`);
+        }
+        // Get the corresponding WebSocket connection
+        const ws = targetServer === 'server1' ? this.ws1 : this.ws2;
+        const state = targetServer === 'server1' ? this.state1 : this.state2;
+        if (!ws || ws.readyState !== ws_1.default.OPEN) {
+            console.error(`[SEND_MESSAGE] ${targetServer} not connected for session ${sessionId}`);
+            throw new Error(`${targetServer} is not available`);
+        }
+        try {
+            ws.send(JSON.stringify(message));
+            console.log(`[SEND_MESSAGE] Message sent to ${targetServer} for session ${sessionId}, msgType=${message.msgType}`);
+        }
+        catch (error) {
+            console.error(`[SEND_MESSAGE] Failed to send to ${targetServer}:`, error);
+            throw error;
+        }
+    }
     /**
      * Send tasks cancel response to specific server
      */
@@ -591,8 +766,8 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             id: message.id,
             serverId: sourceServer,
         });
-        // Remove session mapping
-        this.sessionServerMap.delete(sessionId);
+        // Mark session for cleanup instead of immediate deletion
+        this.markSessionForCleanup(sessionId, sourceServer, this.config.sessionCleanupTimeoutMs ?? XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS);
     }
     /**
      * Handle clear message (legacy format)
@@ -606,7 +781,8 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
             id: message.id,
             serverId: sourceServer,
         });
-        this.sessionServerMap.delete(message.sessionId);
+        // Mark session for cleanup instead of immediate deletion
+        this.markSessionForCleanup(message.sessionId, sourceServer, this.config.sessionCleanupTimeoutMs ?? XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS);
     }
     /**
      * Handle tasks/cancel message
@@ -636,7 +812,7 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     /**
      * Convert A2AResponseMessage to JSON-RPC 2.0 format
      */
-    convertToJsonRpcFormat(response, taskId, isFinal = true, append = false) {
+    convertToJsonRpcFormat(response, taskId, isFinal = true, append = true) {
         const artifactId = `artifact_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
         if (response.status === "error" && response.error) {
             return {
@@ -650,9 +826,11 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
         }
         const parts = [];
         if (response.content.type === "text" && response.content.text) {
+            // When isFinal=true, use empty string for text (no content needed for final chunk)
+            const textContent = isFinal ? "" : response.content.text;
             parts.push({
                 kind: "text",
-                text: response.content.text,
+                text: textContent,
             });
         }
         else if (response.content.type === "file") {
@@ -665,10 +843,11 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
                 },
             });
         }
+        // When isFinal=true, append should be true and text should be empty
         const artifactEvent = {
             taskId: taskId,
             kind: "artifact-update",
-            append: append,
+            append: isFinal ? true : append,
             lastChunk: isFinal,
             final: isFinal,
             artifact: {
@@ -918,6 +1097,86 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     removeSession(sessionId) {
         this.sessionServerMap.delete(sessionId);
     }
+    /**
+     * Mark a session for delayed cleanup
+     * @param sessionId The session ID to mark for cleanup
+     * @param serverId The server ID associated with this session
+     * @param timeoutMs Timeout in milliseconds before forcing cleanup
+     */
+    markSessionForCleanup(sessionId, serverId, timeoutMs) {
+        // Check if already marked
+        const existingState = this.sessionCleanupStateMap.get(sessionId);
+        if (existingState) {
+            // Already pending cleanup, reset timeout
+            if (existingState.cleanupTimeoutId) {
+                clearTimeout(existingState.cleanupTimeoutId);
+            }
+            console.log(`[CLEANUP] Session ${sessionId} already pending cleanup, resetting timeout`);
+        }
+        // Create new cleanup state
+        const newState = {
+            sessionId,
+            serverId,
+            markedForCleanupAt: Date.now(),
+            reason: 'user_cleared',
+        };
+        // Start cleanup timeout
+        const timeoutId = setTimeout(() => {
+            console.log(`[CLEANUP] Timeout reached for session ${sessionId}, forcing cleanup`);
+            this.forceCleanupSession(sessionId);
+        }, timeoutMs);
+        newState.cleanupTimeoutId = timeoutId;
+        this.sessionCleanupStateMap.set(sessionId, newState);
+        console.log(`[CLEANUP] Session ${sessionId} marked for cleanup (timeout: ${timeoutMs}ms)`);
+    }
+    /**
+     * Force cleanup a session immediately
+     * @param sessionId The session ID to cleanup
+     */
+    forceCleanupSession(sessionId) {
+        // Check if already cleaned
+        const state = this.sessionCleanupStateMap.get(sessionId);
+        if (!state) {
+            console.log(`[CLEANUP] Session ${sessionId} already cleaned up, skipping`);
+            return;
+        }
+        // Clear timeout
+        if (state.cleanupTimeoutId) {
+            clearTimeout(state.cleanupTimeoutId);
+        }
+        // Remove from both maps
+        this.sessionServerMap.delete(sessionId);
+        this.sessionCleanupStateMap.delete(sessionId);
+        console.log(`[CLEANUP] Session ${sessionId} cleanup completed`);
+    }
+    /**
+     * Check if a session is pending cleanup
+     * @param sessionId The session ID to check
+     * @returns True if session is pending cleanup
+     */
+    isSessionPendingCleanup(sessionId) {
+        return this.sessionCleanupStateMap.has(sessionId);
+    }
+    /**
+     * Get cleanup state for a session
+     * @param sessionId The session ID to check
+     * @returns Cleanup state if exists, undefined otherwise
+     */
+    getSessionCleanupState(sessionId) {
+        return this.sessionCleanupStateMap.get(sessionId);
+    }
+    /**
+     * Update accumulated text for a pending cleanup session
+     * @param sessionId The session ID
+     * @param text The accumulated text
+     */
+    updateAccumulatedTextForCleanup(sessionId, text) {
+        const state = this.sessionCleanupStateMap.get(sessionId);
+        if (state) {
+            state.accumulatedText = text;
+        }
+    }
 }
 exports.XiaoYiWebSocketManager = XiaoYiWebSocketManager;
+XiaoYiWebSocketManager.DEFAULT_CLEANUP_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
 XiaoYiWebSocketManager.STABLE_CONNECTION_THRESHOLD = 10000; // 10 seconds

package/dist/xy-bot.d.ts

@@ -0,0 +1,19 @@
+import type { OpenClawConfig, RuntimeEnv } from "openclaw/dist/plugin-sdk/index.js";
+type ClawdbotConfig = OpenClawConfig;
+import type { A2AJsonRpcRequest } from "./types.js";
+/**
+ * Parameters for handling an XY message.
+ */
+export interface HandleXYMessageParams {
+    cfg: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    message: A2AJsonRpcRequest;
+    accountId: string;
+}
+/**
+ * Handle an incoming A2A message.
+ * This is the main entry point for message processing.
+ * Runtime is expected to be validated before calling this function.
+ */
+export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;
+export {};