@ynhcj/xiaoyi-channel 0.0.89-beta → 0.0.89-next

package/dist/src/message-queue.js

@@ -0,0 +1,51 @@
+const MAX_QUEUE_SIZE = 1000;
+/**
+ * Simple message queue for buffering outbound WebSocket messages
+ * during disconnection and reconnection stabilization period.
+ */
+export class MessageQueue {
+    items = [];
+    log;
+    constructor(log) {
+        this.log = log ?? console.log;
+    }
+    /** Enqueue a message. Drops oldest if over limit. */
+    enqueue(message) {
+        if (this.items.length >= MAX_QUEUE_SIZE) {
+            this.log(`[MessageQueue] Queue full (${MAX_QUEUE_SIZE}), dropping oldest message`);
+            this.items.shift();
+        }
+        this.items.push(message);
+        this.log(`[MessageQueue] Enqueued message, queue size: ${this.items.length}`);
+    }
+    /** Flush all queued messages by calling sendFn for each, then clear. */
+    flush(sendFn) {
+        const count = this.items.length;
+        if (count === 0) {
+            this.log("[MessageQueue] Queue empty, nothing to flush");
+            return;
+        }
+        this.log(`[MessageQueue] Flushing ${count} queued messages`);
+        for (const msg of this.items) {
+            try {
+                sendFn(msg);
+            }
+            catch (err) {
+                this.log(`[MessageQueue] Error flushing message: ${err}`);
+            }
+        }
+        this.items = [];
+        this.log(`[MessageQueue] Flush complete`);
+    }
+    /** Clear all queued messages without sending. */
+    clear() {
+        const count = this.items.length;
+        this.items = [];
+        if (count > 0) {
+            this.log(`[MessageQueue] Cleared ${count} messages`);
+        }
+    }
+    get size() {
+        return this.items.length;
+    }
+}

package/dist/src/monitor.js

@@ -1,10 +1,14 @@
 import { resolveXYConfig } from "./config.js";
-import { getXYWebSocketManager, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
+import { getXYWebSocketManager, setClientRuntime, diagnoseAllManagers, cleanupOrphanConnections, removeXYWebSocketManager } from "./client.js";
 import { handleXYMessage } from "./bot.js";
 import { parseA2AMessage } from "./parser.js";
-import { hasActiveTask } from "./task-manager.js";
+import { hasActiveTask, getAllActiveTaskBindings } from "./task-manager.js";
+import { sendA2AResponse } from "./formatter.js";
 import { handleTriggerEvent } from "./trigger-handler.js";
+import { handleSelfEvolutionEvent, handleSelfEvolutionStateGetEvent } from "./self-evolution-handler.js";
+import { handleLoginTokenEvent } from "./login-token-handler.js";
 import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
+import { cleanupStaleSessions, getActiveSessionCount, cleanupAllSessions } from "./tools/session-manager.js";
 /**
  * Per-session serial queue that ensures messages from the same session are processed
  * in arrival order while allowing different sessions to run concurrently.
@@ -47,8 +51,10 @@ export async function monitorXYProvider(opts = {}) {
             opts.setStatus({ lastEventAt: Date.now(), lastInboundAt: Date.now() });
         }
         : undefined;
+    // ✅ Set runtime for WebSocket manager logging before creating/getting manager
+    setClientRuntime(runtime);
     // 🔍 Diagnose WebSocket managers before gateway start
-    console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
+    log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
     diagnoseAllManagers();
     // Get WebSocket manager (cached)
     const wsManager = getXYWebSocketManager(account);
@@ -137,7 +143,7 @@ export async function monitorXYProvider(opts = {}) {
             opts.setStatus?.({ connected: true });
         };
         const disconnectedHandler = (serverId) => {
-            console.warn(`XY gateway: ${serverId} disconnected`);
+            log(`XY gateway: ${serverId} disconnected`);
             loggedServers.delete(serverId);
             // ✅ Report disconnection status (only if all servers disconnected)
             if (loggedServers.size === 0) {
@@ -156,16 +162,30 @@ export async function monitorXYProvider(opts = {}) {
                 error(`[MONITOR] Failed to handle trigger-event:`, err);
             });
         };
+        const selfEvolutionHandler = (context) => {
+            log(`[MONITOR] Received self-evolution-event, dispatching to handler...`);
+            handleSelfEvolutionEvent(context, runtime);
+        };
+        const selfEvolutionStateGetHandler = (context) => {
+            log(`[MONITOR] Received self-evolution-state-get-event, dispatching to handler...`);
+            handleSelfEvolutionStateGetEvent(context, account, runtime, wsManager).catch((err) => {
+                error(`[MONITOR] Failed to handle self-evolution-state-get-event:`, err);
+            });
+        };
+        const loginTokenEventHandler = (context) => {
+            log(`[MONITOR] Received login-token-event, dispatching to handler...`);
+            handleLoginTokenEvent(context, runtime);
+        };
         const cleanup = () => {
             log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
-            console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
+            log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
             diagnoseAllManagers();
             // Stop health check interval
             if (healthCheckInterval) {
                 clearInterval(healthCheckInterval);
                 healthCheckInterval = null;
-                console.log("⏸️  Stopped periodic health check");
+                log("⏸️  Stopped periodic health check");
             }
             // Remove event handlers to prevent duplicate calls on gateway restart
             wsManager.off("message", messageHandler);
@@ -173,20 +193,53 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("disconnected", disconnectedHandler);
             wsManager.off("error", errorHandler);
             wsManager.off("trigger-event", triggerEventHandler);
+            wsManager.off("self-evolution-event", selfEvolutionHandler);
+            wsManager.off("self-evolution-state-get-event", selfEvolutionStateGetHandler);
+            wsManager.off("login-token-event", loginTokenEventHandler);
             // ✅ 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
             removeXYWebSocketManager(account);
+            // Clean up all active sessions
+            cleanupAllSessions();
             loggedServers.clear();
             activeMessages.clear();
-            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages`);
+            log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages and sessions`);
             // 🔍 Diagnose after cleanup
-            console.log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
+            log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
             diagnoseAllManagers();
         };
-        const handleAbort = () => {
-            log("XY gateway: abort signal received, stopping");
+        const handleAbort = async () => {
+            log("XY gateway: abort signal received, sending notifications before stopping");
+            // 📤 Send restart notification to all active sessions before disconnecting
+            try {
+                const activeBindings = getAllActiveTaskBindings();
+                if (activeBindings.length > 0) {
+                    const config = resolveXYConfig(cfg);
+                    const notificationText = "Gateway即将重启，重启期间可能短暂出现\u201c环境异常\u201d提示，请稍候并耐心重试~";
+                    log(`[MONITOR] 📤 Sending restart notifications to ${activeBindings.length} active session(s)`);
+                    const sendPromises = activeBindings.map(binding => sendA2AResponse({
+                        config,
+                        sessionId: binding.sessionId,
+                        taskId: binding.currentTaskId,
+                        messageId: binding.currentMessageId,
+                        text: notificationText,
+                        append: false,
+                        final: true,
+                    }).catch(err => {
+                        error(`[MONITOR] Failed to send restart notification to session ${binding.sessionId}: ${String(err)}`);
+                    }));
+                    await Promise.all(sendPromises);
+                    log(`[MONITOR] ✅ Restart notifications sent to ${activeBindings.length} session(s)`);
+                }
+                else {
+                    log(`[MONITOR] No active sessions, skipping restart notifications`);
+                }
+            }
+            catch (err) {
+                error(`[MONITOR] Error sending restart notifications: ${String(err)}`);
+            }
             cleanup();
             log("XY gateway stopped");
             resolve();
@@ -203,15 +256,24 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("disconnected", disconnectedHandler);
         wsManager.on("error", errorHandler);
         wsManager.on("trigger-event", triggerEventHandler);
+        wsManager.on("self-evolution-event", selfEvolutionHandler);
+        wsManager.on("self-evolution-state-get-event", selfEvolutionStateGetHandler);
+        wsManager.on("login-token-event", loginTokenEventHandler);
         // Start periodic health check (every 6 hours)
-        console.log("🏥 Starting periodic health check (every 6 hours)...");
+        log("🏥 Starting periodic health check (every 6 hours)...");
         healthCheckInterval = setInterval(() => {
-            console.log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
+            log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
             diagnoseAllManagers();
             // Auto-cleanup orphan connections
             const cleaned = cleanupOrphanConnections();
             if (cleaned > 0) {
-                console.log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
+                log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
+            }
+            // Cleanup stale sessions (older than 10min TTL)
+            const cleanedSessions = cleanupStaleSessions();
+            const remainingSessions = getActiveSessionCount();
+            if (cleanedSessions > 0 || remainingSessions > 0) {
+                log(`🧹 [HEALTH CHECK] Sessions: cleaned=${cleanedSessions}, active=${remainingSessions}`);
             }
             // Cleanup stale temp files (older than 24 hours)
             void cleanupStaleTempFiles();

package/dist/src/outbound.js

@@ -4,6 +4,7 @@ import { XYPushService } from "./push.js";
 import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { savePushData } from "./utils/pushdata-manager.js";
 import { getAllPushIds } from "./utils/pushid-manager.js";
+import { logger } from "./utils/logger.js";
 // Special marker for default push delivery when no target is specified
 const DEFAULT_PUSH_MARKER = "default";
 // File extension to MIME type mapping
@@ -57,7 +58,7 @@ export const xyOutbound = {
     resolveTarget: ({ cfg, to, accountId, mode }) => {
         // If no target provided, use default marker for push delivery
         if (!to || to.trim() === "") {
-            console.log(`[xyOutbound.resolveTarget] No target specified, using default push marker`);
+            logger.log(`[xyOutbound.resolveTarget] No target specified, using default push marker`);
             return {
                 ok: true,
                 to: DEFAULT_PUSH_MARKER,
@@ -66,24 +67,24 @@ export const xyOutbound = {
         const trimmedTo = to.trim();
         // If the target doesn't contain "::", try to enhance it with taskId from session context
         if (!trimmedTo.includes("::")) {
-            console.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
+            logger.log(`[xyOutbound.resolveTarget] Target "${trimmedTo}" missing taskId, looking up session context`);
             // Try to get the current session context
             const sessionContext = getCurrentSessionContext();
             if (sessionContext && sessionContext.sessionId === trimmedTo) {
                 const enhancedTarget = `${trimmedTo}::${sessionContext.taskId}`;
-                console.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
+                logger.log(`[xyOutbound.resolveTarget] Enhanced target: ${enhancedTarget}`);
                 return {
                     ok: true,
                     to: enhancedTarget,
                 };
             }
             else {
-                console.log(`[xyOutbound.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
+                logger.log(`[xyOutbound.resolveTarget] Could not find matching session context for "${trimmedTo}"`);
                 // Still return the original target, but it may fail in sendMedia
             }
         }
         // Otherwise, use the provided target (either already in correct format or for sendText)
-        console.log(`[xyOutbound.resolveTarget] Using provided target:`, trimmedTo);
+        logger.log(`[xyOutbound.resolveTarget] Using provided target:`, trimmedTo);
         return {
             ok: true,
             to: trimmedTo,
@@ -95,36 +96,36 @@ export const xyOutbound = {
         // Handle default push marker (for cron jobs without explicit target)
         let actualTo = to;
         if (to === DEFAULT_PUSH_MARKER) {
-            console.log(`[xyOutbound.sendText] Using default push delivery (no specific target)`);
+            logger.log(`[xyOutbound.sendText] Using default push delivery (no specific target)`);
             // For push notifications, we don't need a specific target
             // The push service will handle it based on config
             actualTo = config.defaultSessionId || "";
         }
         // 1. 持久化推送消息内容，获取 pushDataId
-        console.log(`[xyOutbound.sendText] Saving push data to local storage...`);
+        logger.log(`[xyOutbound.sendText] Saving push data to local storage...`);
         let pushDataId;
         try {
             pushDataId = await savePushData(text);
-            console.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId.substring(0, 20)}`);
+            logger.log(`[xyOutbound.sendText] ✅ Push data saved with ID: ${pushDataId.substring(0, 20)}`);
         }
         catch (error) {
-            console.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
+            logger.error(`[xyOutbound.sendText] ❌ Failed to save push data:`, error);
             // 如果持久化失败，仍然继续发送（不阻塞主流程）
             pushDataId = "";
         }
         // 2. 读取所有 pushId
-        console.log(`[xyOutbound.sendText] Loading all pushIds...`);
+        logger.log(`[xyOutbound.sendText] Loading all pushIds...`);
         let pushIdList = [];
         try {
             pushIdList = await getAllPushIds();
-            console.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
+            logger.log(`[xyOutbound.sendText] ✅ Loaded ${pushIdList.length} pushIds`);
         }
         catch (error) {
-            console.error(`[xyOutbound.sendText] ❌ Failed to load pushIds:`, error);
+            logger.error(`[xyOutbound.sendText] ❌ Failed to load pushIds:`, error);
         }
         // 3. 如果 pushIdList 为空，回退到原有逻辑（使用 config pushId）
         if (pushIdList.length === 0) {
-            console.log(`[xyOutbound.sendText] ⚠️ No pushIds found, falling back to config pushId`);
+            logger.log(`[xyOutbound.sendText] ⚠️ No pushIds found, falling back to config pushId`);
             pushIdList = [config.pushId];
         }
         // Create push service
@@ -134,7 +135,7 @@ export const xyOutbound = {
         // Truncate push content to max length 1000
         const pushText = text.length > 1000 ? text.slice(0, 1000) : text;
         // 4. 遍历所有 pushId，依次发送推送通知
-        console.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
+        logger.log(`[xyOutbound.sendText] 📤 Broadcasting to ${pushIdList.length} pushId(s)...`);
         let successCount = 0;
         let failureCount = 0;
         for (const pushId of pushIdList) {
@@ -142,11 +143,11 @@ export const xyOutbound = {
                 // 传入 pushId 和 pushDataId，使用 kind="data" 格式
                 await pushService.sendPush(pushText, title, undefined, actualTo, pushDataId, pushId);
                 successCount++;
-                console.log(`[xyOutbound.sendText] ✅ Sent successfully to pushId: ${pushId.substring(0, 20)}...`);
+                logger.log(`[xyOutbound.sendText] ✅ Sent successfully to pushId: ${pushId.substring(0, 20)}...`);
             }
             catch (error) {
                 failureCount++;
-                console.error(`[xyOutbound.sendText] ❌ Failed to send to pushId: ${pushId.substring(0, 20)}...`, error);
+                logger.error(`[xyOutbound.sendText] ❌ Failed to send to pushId: ${pushId.substring(0, 20)}...`, error);
                 // 单个 pushId 发送失败不影响其他，继续处理下一个
             }
         }
@@ -178,7 +179,7 @@ export const xyOutbound = {
         if (!fileId) {
             throw new Error(`File upload returned empty fileId for: ${mediaUrl}`);
         }
-        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+        logger.log(`[xyOutbound.sendMedia] File uploaded:`, {
             fileId,
             sessionId,
             taskId,
@@ -222,7 +223,7 @@ export const xyOutbound = {
         const { getXYWebSocketManager } = await import("./client.js");
         const wsManager = getXYWebSocketManager(config);
         await wsManager.sendMessage(sessionId, agentResponse);
-        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        logger.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
         // Return message info
         return {
             channel: "xiaoyi-channel",

package/dist/src/provider.d.ts

@@ -1,2 +1,3 @@
-import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-models";
+import type { ProviderPlugin } from "openclaw/plugin-sdk/provider-model-shared";
+export declare function applySelfEvolutionPrompt(systemPrompt: string | undefined, enabled: boolean): string;
 export declare const xiaoyiProvider: ProviderPlugin;