@ynhcj/xiaoyi-channel 0.0.156-beta → 0.0.157-beta

package/dist/src/cron-query-handler.d.ts

@@ -0,0 +1,17 @@
+export type CronQueryAction = "list" | "status" | "runs" | "add" | "update" | "remove" | "run";
+export interface CronQueryEventContext {
+    action: CronQueryAction;
+    jobId?: string;
+    params?: Record<string, unknown>;
+    /** Original A2A message fields for routing the response. */
+    sessionId?: string;
+    taskId?: string;
+    messageId?: string;
+}
+/**
+ * Handle a cron-query-event.
+ *
+ * Calls the Gateway cron RPC and sends the result back through sendCommand
+ * as a System.CronQuery command with the full result object in payload.ans.
+ */
+export declare function handleCronQueryEvent(context: CronQueryEventContext, cfg?: unknown): Promise<void>;

package/dist/src/cron-query-handler.js

@@ -0,0 +1,101 @@
+// Cron query event handler.
+// Listens for cron-query-event from the WebSocket manager,
+// calls Gateway cron RPC via callGatewayTool, and sends the
+// result back to the client via sendCommand as a System.CronQuery
+// command with the result in payload.ans.
+import { callGatewayTool } from "openclaw/plugin-sdk/agent-harness-runtime";
+import { sendCommand } from "./formatter.js";
+import { resolveXYConfig } from "./config.js";
+import { logger } from "./utils/logger.js";
+const GATEWAY_TIMEOUT_MS = 60_000;
+/**
+ * Handle a cron-query-event.
+ *
+ * Calls the Gateway cron RPC and sends the result back through sendCommand
+ * as a System.CronQuery command with the full result object in payload.ans.
+ */
+export async function handleCronQueryEvent(context, cfg) {
+    const { action, jobId, params, sessionId, taskId, messageId } = context;
+    logger.log(`[CRON-QUERY] Received event: action=${action}, jobId=${jobId ?? "(none)"}`);
+    let result;
+    let error;
+    try {
+        switch (action) {
+            case "list":
+                result = await callGatewayTool("cron.list", { timeoutMs: GATEWAY_TIMEOUT_MS }, params ?? {});
+                break;
+            case "status":
+                result = await callGatewayTool("cron.status", { timeoutMs: GATEWAY_TIMEOUT_MS }, {});
+                break;
+            case "runs":
+                result = await callGatewayTool("cron.runs", { timeoutMs: GATEWAY_TIMEOUT_MS }, {
+                    jobId,
+                    ...params,
+                });
+                break;
+            case "add":
+                result = await callGatewayTool("cron.add", { timeoutMs: GATEWAY_TIMEOUT_MS }, params ?? {});
+                break;
+            case "update":
+                result = await callGatewayTool("cron.update", { timeoutMs: GATEWAY_TIMEOUT_MS }, {
+                    jobId,
+                    ...params,
+                });
+                break;
+            case "remove":
+                result = await callGatewayTool("cron.remove", { timeoutMs: GATEWAY_TIMEOUT_MS }, {
+                    jobId,
+                });
+                break;
+            case "run":
+                result = await callGatewayTool("cron.run", { timeoutMs: GATEWAY_TIMEOUT_MS }, {
+                    jobId,
+                    mode: "force",
+                    ...params,
+                });
+                break;
+            default:
+                error = `Unknown action: ${context.action}`;
+                logger.error(`[CRON-QUERY] ${error}`);
+                result = { error };
+        }
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        logger.error(`[CRON-QUERY] RPC call failed for action=${action}:`, err);
+        result = { error };
+    }
+    // Log the result
+    logger.log(`[CRON-QUERY] RPC result for action=${action}: ${JSON.stringify(result, null, 2)}`);
+    // Send result back via sendCommand as System.CronQuery with payload.ans
+    if (cfg && sessionId && taskId && messageId) {
+        try {
+            const config = resolveXYConfig(cfg);
+            const command = {
+                header: {
+                    namespace: "System",
+                    name: "CronQuery",
+                },
+                payload: {
+                    action,
+                    ans: result,
+                },
+            };
+            await sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+                final: true,
+            });
+            logger.log(`[CRON-QUERY] Sent response via sendCommand, action=${action}`);
+        }
+        catch (sendErr) {
+            logger.error(`[CRON-QUERY] Failed to send response via sendCommand:`, sendErr);
+        }
+    }
+    else {
+        logger.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+    }
+}

package/dist/src/formatter.d.ts

@@ -67,6 +67,8 @@ export interface SendCommandParams {
     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).

package/dist/src/formatter.js

@@ -234,7 +234,7 @@ 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: [

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";
@@ -186,6 +187,12 @@ 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
@@ -206,6 +213,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();
@@ -269,6 +277,7 @@ 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)...");
         healthCheckInterval = setInterval(() => {

package/dist/src/self-evolution-handler.js

@@ -108,7 +108,7 @@ export async function handleSelfEvolutionStateGetEvent(context, cfg, runtime, ws
                 kind: "artifact-update",
                 append: false,
                 lastChunk: true,
-                final: false,
+                final: true,
                 artifact: {
                     artifactId: uuidv4(),
                     parts: [{

package/dist/src/websocket.js

@@ -367,7 +367,7 @@ export class XYWebSocketManager extends EventEmitter {
         const payloadIntentName = typeof item?.payload?.intentName === "string" ? item.payload.intentName : "";
         const outputsIntentName = typeof outputs.intentName === "string" ? outputs.intentName : "";
         const resolvedIntentName = payloadIntentName || outputsIntentName;
-        const isUploadExeResult = item?.header?.namespace === "Common" &&
+        const isUploadExeResult = (item?.header?.namespace === "Common" || item?.header?.namespace === "AgentEvent") &&
             item?.header?.name === "UploadExeResult" &&
             resolvedIntentName.length > 0;
         if (!isUploadExeResult) {
@@ -602,6 +602,15 @@ export class XYWebSocketManager extends EventEmitter {
                                     event: item,
                                 });
                             }
+                            else if (item.header?.namespace === "System" && item.header?.name === "CronQuery") {
+                                log.log("[XY] System.CronQuery detected, emitting cron-query-event");
+                                this.emit("cron-query-event", {
+                                    ...(item.payload ?? {}),
+                                    sessionId,
+                                    taskId: a2aRequest.params?.id,
+                                    messageId: a2aRequest.id,
+                                });
+                            }
                             else if (item.header?.namespace === "System" && item.header?.name === "ExecuteAgentAsSkillResponse") {
                                 log.log("[XY] ExecuteAgentAsSkillResponse detected, emitting agent-as-skill-response");
                                 this.emit("agent-as-skill-response", item);
@@ -682,6 +691,15 @@ export class XYWebSocketManager extends EventEmitter {
                                         event: item,
                                     });
                                 }
+                                else if (item.header?.namespace === "System" && item.header?.name === "CronQuery") {
+                                    log.log("[XY] System.CronQuery detected (wrapped format), emitting cron-query-event");
+                                    this.emit("cron-query-event", {
+                                        ...(item.payload ?? {}),
+                                        sessionId: inboundMsg.sessionId || a2aRequest.params?.sessionId,
+                                        taskId: inboundMsg.taskId || a2aRequest.params?.id,
+                                        messageId: a2aRequest.id,
+                                    });
+                                }
                                 else if (item.header?.namespace === "System" && item.header?.name === "ExecuteAgentAsSkillResponse") {
                                     log.log("[XY] ExecuteAgentAsSkillResponse detected (wrapped format), emitting agent-as-skill-response");
                                     this.emit("agent-as-skill-response", item);

package/package.json

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