@ynhcj/xiaoyi-channel 1.1.26 → 1.1.28

package/dist/src/formatter.d.ts

@@ -17,6 +17,7 @@ export interface SendA2AResponseParams {
     }>;
     errorCode?: number | string;
     errorMessage?: string;
+    log?: boolean;
 }
 /**
  * Send an A2A artifact update response.
@@ -63,12 +64,53 @@ export interface SendCommandParams {
     sessionId: string;
     taskId: string;
     messageId: string;
-    command: A2ACommand;
+    command?: A2ACommand;
+    commands?: A2ACommand[];
+    /** toolCallId from the tool's execute() — used for cron detection via hook-set Map. */
+    toolCallId?: string;
+    /** When true, the artifact-update is sent with final=true. Default: false. */
+    final?: boolean;
 }
 /**
  * Send a command as an artifact update (final=false).
+ *
+ * Cron-aware: if the sessionId starts with the cron prefix ("cron-"),
+ * the command is delivered through the push channel instead of the
+ * WebSocket session, because cron-triggered tool calls have no active
+ * WebSocket session.  The device receives the push, executes the command,
+ * and returns results through the normal WebSocket path — so response
+ * listening in the calling tool works unchanged.
  */
 export declare function sendCommand(params: SendCommandParams): Promise<void>;
+/**
+ * Parameters for sending a card (e.g., HTML H5 card).
+ */
+export interface SendCardParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    /** toolCallId from the tool's execute() — used for cron detection via hook-set Map. */
+    toolCallId?: string;
+    /** When true, the artifact-update is sent with final=true. Default: false. */
+    final?: boolean;
+    /** Array of card data objects to send. */
+    cardsInfo: CardDataObject[];
+}
+/**
+ * Card data object for sending display cards.
+ */
+export interface CardDataObject {
+    cardName: string;
+    cardData: Record<string, any>;
+    displayType: string;
+}
+/**
+ * Send a card (e.g., HTML H5 card) as an artifact update (final=false).
+ *
+ * Cron-aware: same routing logic as sendCommand.
+ */
+export declare function sendCard(params: SendCardParams): Promise<void>;
 /**
  * Parameters for sending a clearContext response.
  */

package/dist/src/formatter.js

@@ -3,11 +3,49 @@ import { v4 as uuidv4 } from "uuid";
 import { getXYWebSocketManager } from "./client.js";
 import { logger } from "./utils/logger.js";
 import { getCurrentTaskId, getCurrentMessageId } from "./task-manager.js";
+import { redactSensitiveText, containsSensitiveInfo } from "./sensitive-redactor.js";
+import { rewriteOutboundApprovalText } from "./approval-bridge.js";
+import { isCronToolCall } from "./tools/session-manager.js";
+// ─────────────────────────────────────────────────────────────
+// 敏感信息脱敏辅助函数
+// ─────────────────────────────────────────────────────────────
+const MESSAGE_CONTENT_KEYS = new Set(["text", "reasoningText", "content", "message"]);
+function redactMessagePayload(value, currentKey) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === "string") {
+        if (currentKey === undefined || MESSAGE_CONTENT_KEYS.has(currentKey)) {
+            return redactSensitiveText(value);
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(item => redactMessagePayload(item, currentKey));
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const key of Object.keys(value)) {
+            result[key] = redactMessagePayload(value[key], key);
+        }
+        return result;
+    }
+    return value;
+}
+function buildTextPreview(text) {
+    if (typeof text !== "string" || text.length === 0) {
+        return "";
+    }
+    return text.length <= 10 ? text : `${text.slice(0, 5)}***${text.slice(-5)}`;
+}
 /**
  * Send an A2A artifact update response.
  */
 export async function sendA2AResponse(params) {
-    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage } = params;
+    const { config, sessionId, taskId, messageId, text, append, final, files, errorCode, errorMessage, log: shouldLog = true } = params;
+    const log = logger.withContext(sessionId, taskId);
+    // 审批桥接：将 OpenClaw 的审批提示翻译成用户友好的确认文案
+    const bridgedText = text === undefined ? text : rewriteOutboundApprovalText(sessionId, text);
     // Build artifact update event
     const artifact = {
         taskId,
@@ -21,10 +59,10 @@ export async function sendA2AResponse(params) {
         },
     };
     // Add text part (even if empty string, to maintain parts structure)
-    if (text !== undefined) {
+    if (bridgedText !== undefined) {
         artifact.artifact.parts.push({
             kind: "text",
-            text,
+            text: bridgedText,
         });
     }
     // Add file parts if provided
@@ -34,6 +72,8 @@ export async function sendA2AResponse(params) {
             data: { fileInfo: files },
         });
     }
+    // 对消息内容字段做敏感信息脱敏，不修改协议层的 id 等字段
+    artifact.artifact.parts = redactMessagePayload(artifact.artifact.parts, "parts");
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
@@ -46,7 +86,7 @@ export async function sendA2AResponse(params) {
             code: errorCode,
             message: errorMessage ?? "任务执行异常，请重试",
         };
-        logger.log(`[A2A_RESPONSE] ⚠️ Including error code: ${errorCode}`);
+        log.log(`[A2A_RESPONSE] Including error code: ${errorCode}`);
     }
     // Send via WebSocket
     const wsManager = getXYWebSocketManager(config);
@@ -57,14 +97,14 @@ export async function sendA2AResponse(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
-    // 📋 Log complete response body
-    logger.log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response: taskId: ${taskId}`);
-    logger.log(`[A2A_RESPONSE]   - append: ${append}`);
-    logger.log(`[A2A_RESPONSE]   - final: ${final}`);
-    logger.log(`[A2A_RESPONSE]   - text: ${text.length <= 10 ? text : text.slice(0, 5) + '***' + text.slice(-5)}`);
-    logger.log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    if (shouldLog) {
+        const redactedText = redactSensitiveText(bridgedText ?? "");
+        log.log(`[A2A_RESPONSE] Sending artifact-update, append=${append}, final=${final}, text=${buildTextPreview(redactedText)}, files=${files?.length ?? 0}, sensitive=${containsSensitiveInfo(bridgedText ?? "")}`);
+    }
     await wsManager.sendMessage(sessionId, outboundMessage);
-    logger.log(`[A2A_RESPONSE] ✅ Message sent successfully`);
+    if (shouldLog) {
+        log.log(`[A2A_RESPONSE] Message sent successfully`);
+    }
 }
 /**
  * Send an A2A artifact-update with reasoningText part.
@@ -73,6 +113,9 @@ export async function sendA2AResponse(params) {
  */
 export async function sendReasoningTextUpdate(params) {
     const { config, sessionId, taskId, messageId, text, append = true } = params;
+    const log = logger.withContext(sessionId, taskId);
+    // 审批桥接
+    const bridgedText = rewriteOutboundApprovalText(sessionId, text);
     const artifact = {
         taskId,
         kind: "artifact-update",
@@ -84,11 +127,13 @@ export async function sendReasoningTextUpdate(params) {
             parts: [
                 {
                     kind: "reasoningText",
-                    reasoningText: text,
+                    reasoningText: bridgedText,
                 },
             ],
         },
     };
+    // 对消息内容字段做敏感信息脱敏
+    artifact.artifact.parts = redactMessagePayload(artifact.artifact.parts, "parts");
     const jsonRpcResponse = {
         jsonrpc: "2.0",
         id: messageId,
@@ -114,21 +159,26 @@ export async function sendStatusUpdate(params) {
     // fall back to closure-captured values
     const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
     const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+    const log = logger.withContext(sessionId, currentTaskId);
+    // 审批桥接和脱敏
+    const bridgedText = rewriteOutboundApprovalText(sessionId, text);
+    const redactedText = redactSensitiveText(bridgedText);
     // Build status update event following A2A protocol standard
+    const statusMessage = redactMessagePayload({
+        role: "agent",
+        parts: [
+            {
+                kind: "text",
+                text: bridgedText,
+            },
+        ],
+    });
     const statusUpdate = {
         taskId: currentTaskId,
         kind: "status-update",
         final: false, // Status updates should not end the stream
         status: {
-            message: {
-                role: "agent",
-                parts: [
-                    {
-                        kind: "text",
-                        text,
-                    },
-                ],
-            },
+            message: statusMessage,
             state,
         },
     };
@@ -147,21 +197,38 @@ export async function sendStatusUpdate(params) {
         taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
-    // 📋 Log complete response body
-    logger.log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
-    logger.log(`[A2A_STATUS]   - taskId: ${currentTaskId}`);
-    logger.log(`[A2A_STATUS]   - text: "${text}"`);
+    // Log complete response body
+    log.log(`[A2A_STATUS] Sending status-update, text="${redactedText}"`);
     await wsManager.sendMessage(sessionId, outboundMessage);
 }
 /**
  * Send a command as an artifact update (final=false).
+ *
+ * Cron-aware: if the sessionId starts with the cron prefix ("cron-"),
+ * the command is delivered through the push channel instead of the
+ * WebSocket session, because cron-triggered tool calls have no active
+ * WebSocket session.  The device receives the push, executes the command,
+ * and returns results through the normal WebSocket path — so response
+ * listening in the calling tool works unchanged.
  */
 export async function sendCommand(params) {
-    const { config, sessionId, taskId, messageId, command } = params;
+    const { config, sessionId, taskId, messageId, toolCallId } = params;
+    const commands = params.commands ?? (params.command ? [params.command] : []);
+    if (commands.length === 0) {
+        throw new Error("sendCommand requires command or commands.");
+    }
+    // ── Cron mode: disabled ────────────────────────────────────────
+    // sendCommandViaPush is disabled in this version. Cron-triggered
+    // tool calls that try to send commands will be rejected.
+    if (sessionId.startsWith("cron-") || isCronToolCall(toolCallId)) {
+        throw new Error("sendCommandViaPush is disabled in this version");
+    }
+    // ── Normal mode: WebSocket ─────────────────────────────────────
     // Dynamic lookup: use latest taskId/messageId from task-manager (handles steer/interrupt),
     // fall back to closure-captured values
     const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
     const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+    const log = logger.withContext(sessionId, currentTaskId);
     // Build artifact update with command as data
     // Wrap command in commands array as per protocol requirement
     const artifact = {
@@ -169,19 +236,21 @@ export async function sendCommand(params) {
         kind: "artifact-update",
         append: false,
         lastChunk: true,
-        final: false, // Commands are not final
+        final: params.final ?? false,
         artifact: {
             artifactId: uuidv4(),
             parts: [
                 {
                     kind: "data",
                     data: {
-                        commands: [command],
+                        commands,
                     },
                 },
             ],
         },
     };
+    // 对消息内容字段做敏感信息脱敏
+    artifact.artifact.parts = redactMessagePayload(artifact.artifact.parts, "parts");
     // Build JSON-RPC response
     const jsonRpcResponse = {
         jsonrpc: "2.0",
@@ -197,16 +266,70 @@ export async function sendCommand(params) {
         taskId: currentTaskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
-    // 📋 Log complete response body
-    logger.log(`[A2A_COMMAND] 📤 Sending A2A command: taskId: ${currentTaskId}`);
+    // Log complete response body
+    log.log(`[A2A_COMMAND] Sending command`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    logger.log(`[A2A_COMMAND] ✅ Command sent successfully`);
+    log.log(`[A2A_COMMAND] Command sent successfully`);
+}
+/**
+ * Send a card (e.g., HTML H5 card) as an artifact update (final=false).
+ *
+ * Cron-aware: same routing logic as sendCommand.
+ */
+export async function sendCard(params) {
+    const { config, sessionId, taskId, messageId, toolCallId } = params;
+    // ── Cron mode: route through push channel ──────────────────────
+    if (sessionId.startsWith("cron-") || isCronToolCall(toolCallId)) {
+        throw new Error("sendCard does not support cron mode");
+    }
+    // ── Normal mode: WebSocket ─────────────────────────────────────
+    const currentTaskId = getCurrentTaskId(sessionId) ?? taskId;
+    const currentMessageId = getCurrentMessageId(sessionId) ?? messageId;
+    const log = logger.withContext(sessionId, currentTaskId);
+    // Build artifact update with cardsInfo as data
+    const artifact = {
+        taskId: currentTaskId,
+        kind: "artifact-update",
+        append: false,
+        lastChunk: true,
+        final: params.final ?? false,
+        artifact: {
+            artifactId: uuidv4(),
+            parts: [
+                {
+                    kind: "data",
+                    data: {
+                        cardsInfo: params.cardsInfo,
+                    },
+                },
+            ],
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: currentMessageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId: currentTaskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    log.log(`[A2A_CARD] Sending card`);
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log.log(`[A2A_CARD] Card sent successfully`);
 }
 /**
  * Send a clearContext response.
  */
 export async function sendClearContextResponse(params) {
     const { config, sessionId, messageId } = params;
+    const log = logger.withContext(sessionId, "");
     // Build JSON-RPC response for clearContext
     const jsonRpcResponse = {
         jsonrpc: "2.0",
@@ -232,13 +355,14 @@ export async function sendClearContextResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
-    logger.log(`Sent clearContext response: sessionId=${sessionId}`);
+    log.log(`[CLEAR_CONTEXT] Sent clearContext response`);
 }
 /**
  * Send a tasks/cancel response.
  */
 export async function sendTasksCancelResponse(params) {
     const { config, sessionId, taskId, messageId } = params;
+    const log = logger.withContext(sessionId, taskId);
     // Build JSON-RPC response for tasks/cancel
     // Note: Using any to bypass type check as the response format differs from standard A2A types
     const jsonRpcResponse = {
@@ -265,13 +389,24 @@ export async function sendTasksCancelResponse(params) {
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
     await wsManager.sendMessage(sessionId, outboundMessage);
-    logger.log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
+    log.log(`[TASKS_CANCEL] Sent tasks/cancel response`);
 }
 /**
  * Send a Trigger response with pushData content.
  */
 export async function sendTriggerResponse(params) {
     const { config, sessionId, taskId, messageId, content } = params;
+    const log = logger.withContext(sessionId, taskId);
+    // 审批桥接和脱敏
+    const bridgedContent = rewriteOutboundApprovalText(sessionId, content);
+    const redactedContent = redactSensitiveText(bridgedContent);
+    // 对消息内容做敏感信息脱敏
+    const artifactParts = redactMessagePayload([
+        {
+            kind: "text",
+            text: bridgedContent,
+        },
+    ], "parts");
     // Build JSON-RPC response for Trigger
     const jsonRpcResponse = {
         jsonrpc: "2.0",
@@ -284,12 +419,7 @@ export async function sendTriggerResponse(params) {
             final: true,
             artifact: {
                 artifactId: uuidv4(),
-                parts: [
-                    {
-                        kind: "text",
-                        text: content,
-                    },
-                ],
+                parts: artifactParts,
             },
         },
         error: {
@@ -306,7 +436,7 @@ export async function sendTriggerResponse(params) {
         taskId,
         msgDetail: JSON.stringify(jsonRpcResponse),
     };
-    logger.log(`[TRIGGER_RESPONSE] Sending Trigger response: sessionId=${sessionId}, taskId=${taskId}`);
+    log.log(`[TRIGGER_RESPONSE] Sending Trigger response, text=${buildTextPreview(redactedContent)}`);
     await wsManager.sendMessage(sessionId, outboundMessage);
-    logger.log(`[TRIGGER_RESPONSE] Trigger response sent successfully`);
+    log.log(`[TRIGGER_RESPONSE] Trigger response sent successfully`);
 }

package/dist/src/monitor.js

@@ -7,6 +7,7 @@ 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 { handleCronQueryEvent } from "./cron-query-handler.js";
 import { cleanupStaleTempFiles } from "./reply-dispatcher.js";
 import { cleanupStaleSessions, getActiveSessionCount, cleanupAllSessions } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
@@ -51,7 +52,7 @@ export async function monitorXYProvider(opts = {}) {
         }
         : undefined;
     // 🔍 Diagnose WebSocket managers before gateway start
-    logger.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before gateway start...");
+    logger.log("[DIAGNOSTICS] Checking WebSocket managers before gateway start...");
     diagnoseAllManagers();
     // Get WebSocket manager (cached)
     const wsManager = getXYWebSocketManager(account, runtime);
@@ -77,12 +78,12 @@ export async function monitorXYProvider(opts = {}) {
         // Event handlers (defined early so they can be referenced in cleanup)
         const messageHandler = (message, sessionId, serverId) => {
             const messageKey = `${sessionId}::${message.id}`;
-            logger.log(`[MONITOR-HANDLER] ####### messageHandler triggered: sessionId=${sessionId}, messageId=${message.id} #######`);
+            logger.log(`[MONITOR-HANDLER] messageHandler triggered: messageId=${message.id}`);
             // ✅ Report health: received a message
             trackEvent?.();
             // Check for duplicate message handling
             if (activeMessages.has(messageKey)) {
-                logger.error(`[MONITOR-HANDLER] ⚠️ WARNING: Duplicate message detected! messageKey=${messageKey}, this may cause duplicate dispatchers!`);
+                logger.error(`[MONITOR-HANDLER] WARNING: Duplicate message detected, messageKey=${messageKey}`);
             }
             activeMessages.add(messageKey);
             const task = async () => {
@@ -103,45 +104,57 @@ export async function monitorXYProvider(opts = {}) {
                 }
                 catch (err) {
                     // ✅ Only log error, don't re-throw to prevent gateway restart
-                    releaseGate();
                     logger.error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
                 }
                 finally {
+                    // 🔑 确保门控始终被释放。handleXYMessage 内部会 catch 所有异常
+                    // 且某些提前返回路径（clearContext、tasks/cancel 等）不会调用
+                    // onInitComplete，因此必须在 finally 中兜底释放。
+                    releaseGate();
                     // Remove from active messages when done
                     activeMessages.delete(messageKey);
                 }
             };
             // 🔑 核心改造：检测steer模式
-            // 需要提前解析消息以获取sessionId
-            try {
-                const parsed = parseA2AMessage(message);
-                const steerMode = cfg.messages?.queue?.mode === "steer";
-                const hasActiveRun = hasActiveTask(parsed.sessionId);
-                if (steerMode && hasActiveRun) {
-                    // Steer模式且有活跃任务：不入队列，直接并发执行
-                    logger.log(`[MONITOR-HANDLER] 🔄 STEER MODE: Executing concurrently for messageKey=${messageKey}`);
-                    logger.log(`[MONITOR-HANDLER]   - sessionId: ${parsed.sessionId}`);
-                    void task().catch((err) => {
-                        logger.error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
-                        activeMessages.delete(messageKey);
-                    });
+            // clearContext / tasks/cancel 没有 params，跳过 parseA2AMessage 直接入队
+            const messageMethod = message.method;
+            if (messageMethod === "clearContext" || messageMethod === "clear_context"
+                || messageMethod === "tasks/cancel" || messageMethod === "tasks_cancel") {
+                void enqueue(sessionId, task).catch((err) => {
+                    logger.error(`XY gateway: queue processing failed: ${String(err)}`);
+                    activeMessages.delete(messageKey);
+                });
+            }
+            else {
+                try {
+                    const parsed = parseA2AMessage(message);
+                    const steerMode = cfg.messages?.queue?.mode === "steer";
+                    const hasActiveRun = hasActiveTask(parsed.sessionId);
+                    if (steerMode && hasActiveRun) {
+                        // Steer模式且有活跃任务：不入队列，直接并发执行
+                        logger.log(`[MONITOR-HANDLER] STEER MODE: Executing concurrently for messageKey=${messageKey}`);
+                        void task().catch((err) => {
+                            logger.error(`XY gateway: concurrent steer task failed for ${messageKey}: ${String(err)}`);
+                            activeMessages.delete(messageKey);
+                        });
+                    }
+                    else {
+                        // 正常模式：入队列串行执行
+                        void enqueue(sessionId, task).catch((err) => {
+                            logger.error(`XY gateway: queue processing failed: ${String(err)}`);
+                            activeMessages.delete(messageKey);
+                        });
+                    }
                 }
-                else {
-                    // 正常模式：入队列串行执行
+                catch (parseErr) {
+                    // 解析失败，回退到正常队列模式
+                    logger.error(`[MONITOR-HANDLER] Failed to parse message for steer detection: ${String(parseErr)}`);
                     void enqueue(sessionId, task).catch((err) => {
-                        logger.error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+                        logger.error(`XY gateway: queue processing failed: ${String(err)}`);
                         activeMessages.delete(messageKey);
                     });
                 }
             }
-            catch (parseErr) {
-                // 解析失败，回退到正常队列模式
-                logger.error(`[MONITOR-HANDLER] Failed to parse message for steer detection: ${String(parseErr)}`);
-                void enqueue(sessionId, task).catch((err) => {
-                    logger.error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
-                    activeMessages.delete(messageKey);
-                });
-            }
         };
         const connectedHandler = (serverId) => {
             if (!loggedServers.has(serverId)) {
@@ -164,9 +177,7 @@ export async function monitorXYProvider(opts = {}) {
             logger.error(`XY gateway: ${serverId} error: ${String(err)}`);
         };
         const triggerEventHandler = (context) => {
-            logger.log(`[MONITOR] 📌 Received trigger-event, dispatching to handler...`);
-            logger.log(`[MONITOR]   - sessionId: ${context.sessionId}`);
-            logger.log(`[MONITOR]   - taskId: ${context.taskId}`);
+            logger.log(`[MONITOR] Received trigger-event, dispatching to handler...`);
             // 异步处理 Trigger 事件，不阻塞主流程
             handleTriggerEvent(context, cfg, runtime, accountId).catch((err) => {
                 logger.error(`[MONITOR] Failed to handle trigger-event:`, err);
@@ -174,7 +185,9 @@ export async function monitorXYProvider(opts = {}) {
         };
         const selfEvolutionHandler = (context) => {
             logger.log(`[MONITOR] Received self-evolution-event, dispatching to handler...`);
-            handleSelfEvolutionEvent(context, runtime);
+            handleSelfEvolutionEvent(context, cfg).catch((err) => {
+                logger.error(`[MONITOR] Failed to handle self-evolution-event:`, err);
+            });
         };
         const selfEvolutionStateGetHandler = (context) => {
             logger.log(`[MONITOR] Received self-evolution-state-get-event, dispatching to handler...`);
@@ -186,16 +199,22 @@ export async function monitorXYProvider(opts = {}) {
             logger.log(`[MONITOR] Received login-token-event, dispatching to handler...`);
             handleLoginTokenEvent(context, runtime);
         };
+        const cronQueryEventHandler = (context) => {
+            logger.log(`[MONITOR] Received cron-query-event, dispatching to handler...`);
+            handleCronQueryEvent(context, cfg).catch((err) => {
+                logger.error(`[MONITOR] Failed to handle cron-query-event:`, err);
+            });
+        };
         const cleanup = () => {
             logger.log("XY gateway: cleaning up...");
             // 🔍 Diagnose before cleanup
-            logger.log("🔍 [DIAGNOSTICS] Checking WebSocket managers before cleanup...");
+            logger.log("[DIAGNOSTICS] Checking WebSocket managers before cleanup...");
             diagnoseAllManagers();
             // Stop health check interval
             if (healthCheckInterval) {
                 clearInterval(healthCheckInterval);
                 healthCheckInterval = null;
-                logger.log("⏸️  Stopped periodic health check");
+                logger.log("Stopped periodic health check");
             }
             // Remove event handlers to prevent duplicate calls on gateway restart
             wsManager.off("message", messageHandler);
@@ -206,6 +225,7 @@ export async function monitorXYProvider(opts = {}) {
             wsManager.off("self-evolution-event", selfEvolutionHandler);
             wsManager.off("self-evolution-state-get-event", selfEvolutionStateGetHandler);
             wsManager.off("login-token-event", loginTokenEventHandler);
+            wsManager.off("cron-query-event", cronQueryEventHandler);
             // ✅ Disconnect the wsManager to prevent connection leaks
             // This is safe because each gateway lifecycle should have clean connections
             wsManager.disconnect();
@@ -215,9 +235,9 @@ export async function monitorXYProvider(opts = {}) {
             cleanupAllSessions();
             loggedServers.clear();
             activeMessages.clear();
-            logger.log(`[MONITOR-HANDLER] 🧹 Cleanup complete, cleared active messages and sessions`);
+            logger.log(`[MONITOR-HANDLER] Cleanup complete, cleared active messages and sessions`);
             // 🔍 Diagnose after cleanup
-            logger.log("🔍 [DIAGNOSTICS] Checking WebSocket managers after cleanup...");
+            logger.log("[DIAGNOSTICS] Checking WebSocket managers after cleanup...");
             diagnoseAllManagers();
         };
         const handleAbort = async () => {
@@ -228,7 +248,7 @@ export async function monitorXYProvider(opts = {}) {
                 if (activeBindings.length > 0) {
                     const config = resolveXYConfig(cfg);
                     const notificationText = "Gateway即将重启，重启期间可能短暂出现\u201c环境异常\u201d提示，请稍候并耐心重试~";
-                    logger.log(`[MONITOR] 📤 Sending restart notifications to ${activeBindings.length} active session(s)`);
+                    logger.log(`[MONITOR] Sending restart notifications to ${activeBindings.length} active session(s)`);
                     const sendPromises = activeBindings.map(binding => sendA2AResponse({
                         config,
                         sessionId: binding.sessionId,
@@ -238,10 +258,10 @@ export async function monitorXYProvider(opts = {}) {
                         append: false,
                         final: true,
                     }).catch(err => {
-                        logger.error(`[MONITOR] Failed to send restart notification to session ${binding.sessionId}: ${String(err)}`);
+                        logger.error(`[MONITOR] Failed to send restart notification: ${String(err)}`);
                     }));
                     await Promise.all(sendPromises);
-                    logger.log(`[MONITOR] ✅ Restart notifications sent to ${activeBindings.length} session(s)`);
+                    logger.log(`[MONITOR] Restart notifications sent to ${activeBindings.length} session(s)`);
                 }
                 else {
                     logger.log(`[MONITOR] No active sessions, skipping restart notifications`);
@@ -269,21 +289,22 @@ export async function monitorXYProvider(opts = {}) {
         wsManager.on("self-evolution-event", selfEvolutionHandler);
         wsManager.on("self-evolution-state-get-event", selfEvolutionStateGetHandler);
         wsManager.on("login-token-event", loginTokenEventHandler);
+        wsManager.on("cron-query-event", cronQueryEventHandler);
         // Start periodic health check (every 6 hours)
-        logger.log("🏥 Starting periodic health check (every 6 hours)...");
+        logger.log("Starting periodic health check (every 6 hours)...");
         healthCheckInterval = setInterval(() => {
-            logger.log("🏥 [HEALTH CHECK] Periodic WebSocket diagnostics...");
+            logger.log("[HEALTH CHECK] Periodic WebSocket diagnostics...");
             diagnoseAllManagers();
             // Auto-cleanup orphan connections
             const cleaned = cleanupOrphanConnections();
             if (cleaned > 0) {
-                logger.log(`🧹 [HEALTH CHECK] Auto-cleaned ${cleaned} manager(s) with orphan connections`);
+                logger.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) {
-                logger.log(`🧹 [HEALTH CHECK] Sessions: cleaned=${cleanedSessions}, active=${remainingSessions}`);
+                logger.log(`[HEALTH CHECK] Sessions: cleaned=${cleanedSessions}, active=${remainingSessions}`);
             }
             // Cleanup stale temp files (older than 24 hours)
             void cleanupStaleTempFiles();