@ynhcj/xiaoyi-channel 0.0.167-beta → 0.0.169-beta

package/dist/src/bot.js

@@ -32,9 +32,9 @@ export async function handleXYMessage(params) {
     try {
         // Check for special messages BEFORE parsing (these have different param structures)
         const messageMethod = message.method;
-        // Handle clearContext messages (params only has sessionId)
+        // Handle clearContext messages (sessionId at top level, no params)
         if (messageMethod === "clearContext" || messageMethod === "clear_context") {
-            const sessionId = message.params?.sessionId;
+            const sessionId = message.sessionId ?? message.params?.sessionId;
             if (!sessionId) {
                 throw new Error("clearContext request missing sessionId in params");
             }
@@ -48,9 +48,9 @@ export async function handleXYMessage(params) {
             });
             return;
         }
-        // Handle tasks/cancel messages
+        // Handle tasks/cancel messages (sessionId at top level, no params)
         if (messageMethod === "tasks/cancel" || messageMethod === "tasks_cancel") {
-            const sessionId = message.params?.sessionId;
+            const sessionId = message.sessionId ?? message.params?.sessionId;
             const taskId = message.params?.id || message.id;
             if (!sessionId) {
                 throw new Error("tasks/cancel request missing sessionId in params");

package/dist/src/cspl/sentinel_hook.js

@@ -15,16 +15,21 @@ export default function register(api) {
         // 生成sessionID
         const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
         logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
-        // 处理 TOOL_INPUT 数据采集、发送数据
+        // 处理 TOOL_INPUT 数据采集、发送数据，根据扫描结果决定是否阻塞
         try {
+            let scanResult = null;
             if (event.toolName === 'exec') {
-                await handleExecToolInput(event, api, sessionId);
+                scanResult = await handleExecToolInput(event, api, sessionId);
             }
             else if (event.toolName === 'message') {
-                await handleMessageToolInput(event, api, sessionId);
+                scanResult = await handleMessageToolInput(event, api, sessionId);
             }
             else {
-                await handleOtherToolInput(event, api, sessionId);
+                scanResult = await handleOtherToolInput(event, api, sessionId);
+            }
+            if (scanResult?.status === 'REJECT') {
+                logger.warn(`[SENTINEL HOOK] TOOL_INPUT REJECT, blocking tool call: ${event.toolName}`);
+                return { block: true, blockReason: `安全扫描检测到风险，已阻止工具调用: ${event.toolName}` };
             }
         }
         catch (error) {

package/dist/src/cspl/utils.d.ts

@@ -14,6 +14,12 @@ export declare function extractFilePathsFromCommand(command: string): string[];
 export declare function calculateContentHash(content: string): string;
 export declare function getFileSizeInKB(filePath: string): number;
 export declare function adjustContentLength(data: any, api: OpenClawPluginApi, fields: string[]): any;
-export declare function handleExecToolInput(event: any, api: OpenClawPluginApi, sessionId: string): Promise<string | null>;
-export declare function handleMessageToolInput(event: any, api: OpenClawPluginApi, sessionId: string): Promise<string | null>;
-export declare function handleOtherToolInput(event: any, api: OpenClawPluginApi, sessionId: string): Promise<void>;
+export declare function handleExecToolInput(event: any, api: OpenClawPluginApi, sessionId: string): Promise<{
+    status: 'ACCEPT' | 'REJECT';
+} | null>;
+export declare function handleMessageToolInput(event: any, api: OpenClawPluginApi, sessionId: string): Promise<{
+    status: 'ACCEPT' | 'REJECT';
+} | null>;
+export declare function handleOtherToolInput(event: any, api: OpenClawPluginApi, sessionId: string): Promise<{
+    status: 'ACCEPT' | 'REJECT';
+} | null>;

package/dist/src/cspl/utils.js

@@ -213,13 +213,14 @@ export function adjustContentLength(data, api, fields) {
     }
     return adjusted;
 }
-// 发送TOOL_INPUT请求并处理响应
+// 发送TOOL_INPUT请求并处理响应，返回扫描结果
 async function sendToolInputRequest(postText, api, sessionId) {
     const response = await callApi(postText, api, sessionId, TOOL_INPUT_ACTION);
     const result = parseSecurityResult(response);
     logger.log(`[SENTINEL HOOK] TOOL_INPUT response: status=${result.status}`);
+    return result;
 }
-// 处理exec工具的TOOL_INPUT数据采集
+// 处理exec工具的TOOL_INPUT数据采集，返回最终扫描结果
 export async function handleExecToolInput(event, api, sessionId) {
     const command = extractInputParams(event, 'exec');
     if (!command) {
@@ -232,6 +233,7 @@ export async function handleExecToolInput(event, api, sessionId) {
         // 场景1：执行代码文件
         logger.log(`[SENTINEL HOOK] Found ${filePaths.length} file(s) in command`);
         const nonExistingFiles = [];
+        let lastResult = null;
         for (const filePath of filePaths) {
             if (!fs.existsSync(filePath)) {
                 nonExistingFiles.push(filePath);
@@ -247,7 +249,10 @@ export async function handleExecToolInput(event, api, sessionId) {
             const postText = JSON.stringify(adjustedData);
             logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for file: ${path.basename(filePath)}, body length: ${postText.length}`);
             try {
-                await sendToolInputRequest(postText, api, sessionId);
+                lastResult = await sendToolInputRequest(postText, api, sessionId);
+                if (lastResult.status === 'REJECT') {
+                    return lastResult;
+                }
             }
             catch (e) {
                 logger.error(`[SENTINEL HOOK] Sending TOOL_INPUT Failed: ${e}`);
@@ -258,6 +263,7 @@ export async function handleExecToolInput(event, api, sessionId) {
             const fileNames = nonExistingFiles.map(f => path.basename(f)).join(', ');
             logger.log(`[SENTINEL HOOK] Non-existing files: ${fileNames}`);
         }
+        return lastResult;
     }
     else {
         // 场景2：直接执行代码（heredoc场景）
@@ -268,10 +274,10 @@ export async function handleExecToolInput(event, api, sessionId) {
         const adjustedData = adjustContentLength(toolInputData, api, ['source']);
         const postText = JSON.stringify(adjustedData);
         logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for direct code execution, body length: ${postText.length}`);
-        await sendToolInputRequest(postText, api, sessionId);
+        return await sendToolInputRequest(postText, api, sessionId);
     }
 }
-// 处理message工具的TOOL_INPUT数据采集
+// 处理message工具的TOOL_INPUT数据采集，返回扫描结果
 export async function handleMessageToolInput(event, api, sessionId) {
     const message = extractInputParams(event, 'message');
     if (!message) {
@@ -285,14 +291,14 @@ export async function handleMessageToolInput(event, api, sessionId) {
     const adjustedData = adjustContentLength(toolInputData, api, ['content']);
     const postText = JSON.stringify(adjustedData);
     logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for message, body length: ${postText.length}`);
-    await sendToolInputRequest(postText, api, sessionId);
+    return await sendToolInputRequest(postText, api, sessionId);
 }
-// 处理其他工具（非 exec 和非 message）的 TOOL_INPUT 数据采集
+// 处理其他工具（非 exec 和非 message）的 TOOL_INPUT 数据采集，返回扫描结果
 export async function handleOtherToolInput(event, api, sessionId) {
     const params = event.params;
     if (!params) {
         logger.log('[SENTINEL HOOK] No params found for tool');
-        return;
+        return null;
     }
     logger.log(`[SENTINEL HOOK] Processing other tool input, toolName: ${event.toolName}`);
     // 将 params 序列化为 JSON 字符串
@@ -305,5 +311,5 @@ export async function handleOtherToolInput(event, api, sessionId) {
     const adjustedData = adjustContentLength(toolInputData, api, ['content']);
     const postText = JSON.stringify(adjustedData);
     logger.log(`[SENTINEL HOOK] Sending TOOL_INPUT for ${event.toolName}, body length: ${postText.length}`);
-    await sendToolInputRequest(postText, api, sessionId);
+    return await sendToolInputRequest(postText, api, sessionId);
 }

package/dist/src/monitor.js

@@ -116,35 +116,45 @@ export async function monitorXYProvider(opts = {}) {
                 }
             };
             // 🔑 核心改造：检测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}`);
-                    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: ${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: ${String(err)}`);
-                    activeMessages.delete(messageKey);
-                });
-            }
         };
         const connectedHandler = (serverId) => {
             if (!loggedServers.has(serverId)) {
@@ -175,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...`);

package/dist/src/self-evolution-handler.d.ts

@@ -1,5 +1,5 @@
 import type { XYWebSocketManager } from "./websocket.js";
-export declare function handleSelfEvolutionEvent(context: any, runtime: any): void;
+export declare function handleSelfEvolutionEvent(context: any, cfg: any): Promise<void>;
 /**
  * 读取 .xiaoyiruntime 中的 selfEvolutionState 并直接通过 wsManager 下发指令回复设备
  * 参考trigger实现：直接使用当前已连接的 wsManager 发送消息，避免 getXYWebSocketManager 返回未连接实例

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

@@ -1,14 +1,20 @@
 import { readFileSync, writeFileSync } from "fs";
 import { v4 as uuidv4 } from "uuid";
+import { resolveXYConfig } from "./config.js";
+import { sendA2AResponse } from "./formatter.js";
 import { logger } from "./utils/logger.js";
 const XIAOYIRUNTIME_PATH = "/home/sandbox/.openclaw/.xiaoyiruntime";
-export function handleSelfEvolutionEvent(context, runtime) {
+export async function handleSelfEvolutionEvent(context, cfg) {
     try {
         const state = context.event?.payload?.selfEvolutionState;
         if (typeof state !== "string") {
             logger.error("[SELF_EVOLUTION] invalid payload: missing selfEvolutionState");
             return;
         }
+        const sessionId = context.sessionId ?? "";
+        const taskId = context.taskId ?? sessionId;
+        const messageId = context.messageId ?? uuidv4();
+        const config = resolveXYConfig(cfg);
         logger.log(`[SELF_EVOLUTION] received state: ${state}`);
         let content;
         try {
@@ -19,6 +25,8 @@ export function handleSelfEvolutionEvent(context, runtime) {
             logger.log(`[SELF_EVOLUTION] ${XIAOYIRUNTIME_PATH} not found, creating new file`);
             writeFileSync(XIAOYIRUNTIME_PATH, `selfEvolutionState=${state}\n`, "utf-8");
             logger.log(`[SELF_EVOLUTION] wrote selfEvolutionState=${state}`);
+            await sendA2AResponse({ config, sessionId, taskId, messageId, text: "", append: false, final: true });
+            logger.log(`[SELF_EVOLUTION] Sent final response (empty, stream end)`);
             return;
         }
         const lines = content.split("\n");
@@ -40,6 +48,9 @@ export function handleSelfEvolutionEvent(context, runtime) {
             writeFileSync(XIAOYIRUNTIME_PATH, updated.join("\n"), "utf-8");
         }
         logger.log(`[SELF_EVOLUTION] updated selfEvolutionState=${state} in ${XIAOYIRUNTIME_PATH}`);
+        // Reply with final empty response to acknowledge the state update
+        await sendA2AResponse({ config, sessionId, taskId, messageId, text: "", append: false, final: true });
+        logger.log(`[SELF_EVOLUTION] Sent final response (empty, stream end)`);
     }
     catch (err) {
         logger.error("[SELF_EVOLUTION] failed to handle event:", err);

package/dist/src/tools/check-plugin-privilege-tool.js

@@ -62,7 +62,9 @@ export function createCheckPluginPrivilegeTool(ctx) {
             "SendShortMessage（发送短信）, " +
             "StartCall（打电话）。" +
             "【多次调用】如果用户的定时任务指令中涉及多个端侧工具，则依次分别调用此工具检查每个工具的权限。如果调用超时失败，最多重试一次。" +
-            "【回复约束】如果工具返回没有授权或其他报错，只需要完整描述没有授权或其他报错内容即可，不需要主动给用户提供解决方案。",
+            "【回复约束】如果工具返回没有授权或其他报错，只需要完整描述没有授权或其他报错内容即可，不需要主动给用户提供解决方案。" +
+            "【使用约束1】只要是创建定时任务且涉及端插件的使用，则必须调用此工具检查权限" +
+            "【使用约束2】如果是定时任务执行过程中，禁止调用此工具，此工具仅在创建定时任务时按需调用",
         parameters: {
             type: "object",
             properties: {

package/dist/src/types.d.ts

@@ -13,8 +13,10 @@ export interface XYChannelConfig {
 export interface A2AJsonRpcRequest {
     jsonrpc: "2.0";
     method: string;
-    params: A2ARequestParams;
+    params?: A2ARequestParams;
     id: string;
+    /** Top-level sessionId for clearContext/tasks/cancel (no params field) */
+    sessionId?: string;
 }
 export interface A2AJsonRpcResponse {
     jsonrpc: "2.0";

package/package.json

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