@ynhcj/xiaoyi 0.0.3-beta → 0.0.4-beta

package/dist/heartbeat.d.ts

@@ -0,0 +1,39 @@
+import WebSocket from "ws";
+export interface HeartbeatConfig {
+    interval: number;
+    timeout: number;
+    message: string;
+}
+/**
+ * Manages heartbeat for a WebSocket connection.
+ * Supports both application-level and protocol-level heartbeats.
+ */
+export declare class HeartbeatManager {
+    private ws;
+    private config;
+    private onTimeout;
+    private serverName;
+    private onHeartbeatSuccess?;
+    private intervalTimer;
+    private timeoutTimer;
+    private lastPongTime;
+    private log;
+    private error;
+    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void, onHeartbeatSuccess?: () => void);
+    /**
+     * Start heartbeat monitoring.
+     */
+    start(): void;
+    /**
+     * Stop heartbeat monitoring.
+     */
+    stop(): void;
+    /**
+     * Send a heartbeat ping.
+     */
+    private sendHeartbeat;
+    /**
+     * Check if connection is healthy based on last pong time.
+     */
+    isHealthy(): boolean;
+}

package/dist/heartbeat.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatManager = void 0;
+// Heartbeat management for WebSocket connections
+const ws_1 = __importDefault(require("ws"));
+/**
+ * Manages heartbeat for a WebSocket connection.
+ * Supports both application-level and protocol-level heartbeats.
+ */
+class HeartbeatManager {
+    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn, onHeartbeatSuccess // ✅ 心跳成功回调，向 OpenClaw 报告健康状态
+    ) {
+        this.ws = ws;
+        this.config = config;
+        this.onTimeout = onTimeout;
+        this.serverName = serverName;
+        this.onHeartbeatSuccess = onHeartbeatSuccess;
+        this.intervalTimer = null;
+        this.timeoutTimer = null;
+        this.lastPongTime = 0;
+        this.log = logFn ?? console.log;
+        this.error = errorFn ?? console.error;
+    }
+    /**
+     * Start heartbeat monitoring.
+     */
+    start() {
+        this.stop(); // Clear any existing timers
+        this.lastPongTime = Date.now();
+        // Setup ping/pong for protocol-level heartbeat
+        this.ws.on("pong", () => {
+            this.lastPongTime = Date.now();
+            if (this.timeoutTimer) {
+                clearTimeout(this.timeoutTimer);
+                this.timeoutTimer = null;
+            }
+            // ✅ Report health: heartbeat successful - notify OpenClaw framework
+            this.onHeartbeatSuccess?.();
+            this.log(`[${this.serverName}] Heartbeat pong received, health reported to OpenClaw`);
+        });
+        // Start interval timer
+        this.intervalTimer = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.config.interval);
+        this.log(`[${this.serverName}] Heartbeat started: interval=${this.config.interval}ms, timeout=${this.config.timeout}ms`);
+    }
+    /**
+     * Stop heartbeat monitoring.
+     */
+    stop() {
+        if (this.intervalTimer) {
+            clearInterval(this.intervalTimer);
+            this.intervalTimer = null;
+        }
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = null;
+        }
+        // Remove pong listener
+        this.ws.off("pong", () => { });
+        this.log(`[${this.serverName}] Heartbeat stopped`);
+    }
+    /**
+     * Send a heartbeat ping.
+     */
+    sendHeartbeat() {
+        if (this.ws.readyState !== ws_1.default.OPEN) {
+            console.warn(`[${this.serverName}] Cannot send heartbeat: WebSocket not open`);
+            return;
+        }
+        try {
+            // Send application-level heartbeat message
+            this.log(`[${this.serverName}] Sending heartbeat frame:`, this.config.message.substring(0, 100));
+            this.ws.send(this.config.message);
+            // Send protocol-level ping
+            this.ws.ping();
+            this.log(`[${this.serverName}] Protocol-level ping sent`);
+            // Setup timeout timer
+            this.timeoutTimer = setTimeout(() => {
+                this.error(`[${this.serverName}] Heartbeat timeout - no pong received`);
+                this.onTimeout();
+            }, this.config.timeout);
+        }
+        catch (error) {
+            this.error(`[${this.serverName}] Failed to send heartbeat:`, error);
+        }
+    }
+    /**
+     * Check if connection is healthy based on last pong time.
+     */
+    isHealthy() {
+        if (this.lastPongTime === 0) {
+            return true; // Not started yet
+        }
+        const timeSinceLastPong = Date.now() - this.lastPongTime;
+        return timeSinceLastPong < this.config.interval + this.config.timeout;
+    }
+}
+exports.HeartbeatManager = HeartbeatManager;

package/dist/websocket.d.ts

@@ -13,6 +13,8 @@ export declare class XiaoYiWebSocketManager extends EventEmitter {
     private heartbeatTimeout1?;
     private heartbeatTimeout2?;
     private appHeartbeatInterval?;
+    private heartbeat1?;
+    private heartbeat2?;
     private reconnectTimeout1?;
     private reconnectTimeout2?;
     private stableConnectionTimer1?;

package/dist/websocket.js

@@ -8,6 +8,7 @@ const ws_1 = __importDefault(require("ws"));
 const events_1 = require("events");
 const url_1 = require("url");
 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) {
@@ -141,9 +142,13 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     async connectToServer1() {
         console.log(`[Server1] Connecting to ${this.config.wsUrl1}...`);
         try {
-            // ✅ Close existing connection before creating new one to prevent ghost connections
+            // ✅ 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();
@@ -163,6 +168,24 @@ 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");
+            });
             this.setupWebSocketHandlers(this.ws1, 'server1');
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
@@ -183,8 +206,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);
@@ -200,9 +224,13 @@ class XiaoYiWebSocketManager extends events_1.EventEmitter {
     async connectToServer2() {
         console.log(`[Server2] Connecting to ${this.config.wsUrl2}...`);
         try {
-            // ✅ Close existing connection before creating new one to prevent ghost connections
+            // ✅ 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();
@@ -222,6 +250,24 @@ 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");
+            });
             this.setupWebSocketHandlers(this.ws2, 'server2');
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => reject(new Error("Connection timeout")), 30000);
@@ -242,8 +288,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);
@@ -259,6 +306,17 @@ 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) {
             try {

package/dist/xy-monitor.js

@@ -125,9 +125,6 @@ async function monitorXYProvider(opts = {}) {
         };
         const cleanup = () => {
             log("XY gateway: cleaning up...");
-            // // 🔍 Diagnose before cleanup
-            // console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
-            // diagnoseAllManagers();
             // Stop health check interval
             if (healthCheckInterval) {
                 clearInterval(healthCheckInterval);
@@ -139,17 +136,12 @@ async function monitorXYProvider(opts = {}) {
             wsManager.off("connected", connectedHandler);
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
-            // ✅ Disconnect the wsManager to prevent connection leaks
-            // This is safe because each gateway lifecycle should have clean connections
-            wsManager.disconnect();
-            // ✅ Remove manager from cache to prevent reusing dirty state
+            // ✅ Remove manager from cache - this will also disconnect
+            // removeXYWebSocketManager internally calls manager.disconnect()
             (0, xy_client_js_1.removeXYWebSocketManager)(account);
             loggedServers.clear();
             activeMessages.clear();
             log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
-            // // 🔍 Diagnose after cleanup
-            // console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
-            // diagnoseAllManagers();
         };
         const handleAbort = () => {
             log("XY gateway: abort signal received, stopping");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynhcj/xiaoyi",
-  "version": "0.0.3-beta",
+  "version": "0.0.4-beta",
   "description": "XiaoYi channel plugin for OpenClaw",
   "type": "module",
   "main": "./dist/index.js",