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

package/dist/src/channel.js

@@ -2,15 +2,55 @@ import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./conf
 import { xyConfigSchema } from "./config-schema.js";
 import { xyOutbound } from "./outbound.js";
 import { filterToolsByDevice } from "./tools/device-tool-map.js";
-import { getCurrentSessionContext, registerSession } from "./tools/session-manager.js";
-import { createAllTools } from "./tools/create-all-tools.js";
+import { getCurrentSessionContext } from "./tools/session-manager.js";
 import { logger } from "./utils/logger.js";
-/**
- * Prefix used for synthetic sessionIds created during cron-triggered tool
- * execution.  `sendCommand()` checks this prefix to route commands through
- * the push channel instead of the (non-existent) WebSocket session.
- */
-const CRON_SESSION_PREFIX = "cron-";
+// Static tool imports (3.24 pattern)
+import { locationTool } from "./tools/location-tool.js";
+import { xiaoyiGuiTool } from "./tools/xiaoyi-gui-tool.js";
+import { sendFileToUserTool } from "./tools/send-file-to-user-tool.js";
+import { sendHtmlCardTool } from "./tools/send-html-card-tool.js";
+import { viewPushResultTool } from "./tools/view-push-result-tool.js";
+import { imageReadingTool } from "./tools/image-reading-tool.js";
+import { timestampToUtc8Tool } from "./tools/timestamp-to-utc8-tool.js";
+import { saveSelfEvolutionSkillTool } from "./tools/save-self-evolution-skill-tool.js";
+import { callDeviceTool } from "./tools/call-device-tool.js";
+import { getNoteToolSchemaTool } from "./tools/get-note-tool-schema.js";
+import { getCalendarToolSchemaTool } from "./tools/get-calendar-tool-schema.js";
+import { getContactToolSchemaTool } from "./tools/get-contact-tool-schema.js";
+import { getPhotoToolSchemaTool } from "./tools/get-photo-tool-schema.js";
+import { getDeviceFileToolSchemaTool } from "./tools/get-device-file-tool-schema.js";
+import { getAlarmToolSchemaTool } from "./tools/get-alarm-tool-schema.js";
+import { getCollectionToolSchemaTool } from "./tools/get-collection-tool-schema.js";
+import { loginTokenTool } from "./tools/login-token-tool.js";
+import { agentAsSkillTool } from "./tools/agent-as-skill-tool.js";
+import { discoverCrossDevicesTool } from "./tools/discover-cross-devices-tool.js";
+import { sendCrossDeviceTaskTool } from "./tools/send-cross-device-task-tool.js";
+import { displayA2UICardByPathTool } from "./tools/display-a2ui-card-bypath-tool.js";
+import { checkPluginPrivilegeTool } from "./tools/check-plugin-privilege-tool.js";
+const ALL_TOOLS = [
+    locationTool,
+    discoverCrossDevicesTool,
+    sendCrossDeviceTaskTool,
+    displayA2UICardByPathTool,
+    callDeviceTool,
+    getNoteToolSchemaTool,
+    getCalendarToolSchemaTool,
+    getContactToolSchemaTool,
+    getPhotoToolSchemaTool,
+    xiaoyiGuiTool,
+    getDeviceFileToolSchemaTool,
+    getAlarmToolSchemaTool,
+    getCollectionToolSchemaTool,
+    sendFileToUserTool,
+    sendHtmlCardTool,
+    viewPushResultTool,
+    imageReadingTool,
+    timestampToUtc8Tool,
+    saveSelfEvolutionSkillTool,
+    loginTokenTool,
+    agentAsSkillTool,
+    checkPluginPrivilegeTool,
+];
 /**
  * Xiaoyi Channel Plugin for OpenClaw.
  * Implements Xiaoyi A2A protocol with dual WebSocket connections.
@@ -32,7 +72,7 @@ export const xyPlugin = {
         ],
     },
     capabilities: {
-        chatTypes: ["direct"], // Only private chat (no group support)
+        chatTypes: ["direct"],
         polls: false,
         threads: false,
         media: true,
@@ -49,59 +89,11 @@ export const xyPlugin = {
         schema: xyConfigSchema,
     },
     outbound: xyOutbound,
-    /**
-     * Provide channel-specific agent tools.
-     *
-     * Two execution contexts are supported:
-     *
-     *  1. **Normal (WebSocket) session** – `getCurrentSessionContext()` returns
-     *     a context that was registered by bot.ts during message processing.
-     *     Tools send commands through the WebSocket and listen for responses.
-     *
-     *  2. **Cron / scheduled-task session** – openclaw's cron runner calls
-     *     `agentTools({ cfg })` without an active WebSocket session.  When no
-     *     session context exists but `cfg` is provided, we create a synthetic
-     *     "cron session" with `isCron: true` and a `cron-`-prefixed sessionId.
-     *     `sendCommand()` detects this prefix and routes commands through the
-     *     push channel.  Response listening (WebSocket events) works unchanged
-     *     because the gateway WebSocket connection is always active.
-     */
-    agentTools: (params) => {
-        let ctx = getCurrentSessionContext();
-        // ── Cron / non-session fallback ──────────────────────────────
-        // When no active xy WebSocket session exists but the openclaw cfg
-        // is provided (framework calls agentTools({ cfg })), create a
-        // synthetic "cron session".  This enables cron-triggered agent
-        // turns and cross-channel tool calls to use xiaoyi tools via the
-        // push channel.  sendCommand() detects the "cron-" sessionId
-        // prefix and routes commands through push instead of WebSocket.
-        if (!ctx && params?.cfg) {
-            try {
-                const config = resolveXYConfig(params.cfg);
-                const cronId = `${CRON_SESSION_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-                ctx = {
-                    config,
-                    sessionId: cronId,
-                    taskId: cronId,
-                    messageId: cronId,
-                    agentId: "default",
-                    isCron: true,
-                };
-                // Register so getCurrentSessionContext() fallback can find it
-                registerSession(`__cron__${cronId}`, ctx);
-                logger.log(`[CRON-TOOLS] Created cron session context: ${cronId}`);
-            }
-            catch (err) {
-                logger.error("[CRON-TOOLS] Failed to create cron context:", err);
-            }
-        }
-        if (!ctx) {
-            logger.log("[CREATE-ALL-TOOLS] no session context, returning empty tools list");
-            return [];
-        }
-        const allTools = createAllTools(ctx);
-        const filtered = filterToolsByDevice(allTools, ctx.deviceType);
-        logger.log(`[DEVICE-FILTER] deviceType=${ctx.deviceType ?? "(none)"}, tools: ${allTools.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
+    /** Static tool list (3.24 pattern). Tools read SessionContext at execute time via ALS. */
+    agentTools: () => {
+        const ctx = getCurrentSessionContext();
+        const filtered = filterToolsByDevice(ALL_TOOLS, ctx?.deviceType);
+        logger.log(`[DEVICE-FILTER] deviceType=${ctx?.deviceType ?? "(none)"}, tools: ${ALL_TOOLS.length} → ${filtered.length} (${filtered.map(t => t.name).join(", ")})`);
         return filtered;
     },
     messaging: {
@@ -113,7 +105,6 @@ export const xyPlugin = {
         },
         targetResolver: {
             looksLikeId: (raw) => {
-                // 信任所有非空字符串作为有效的 sessionId
                 const trimmed = raw.trim();
                 return trimmed.length > 0;
             },
@@ -139,16 +130,20 @@ export const xyPlugin = {
     reload: {
         configPrefixes: ["channels.xiaoyi-channel"],
     },
-    // Gateway adapter for receiving messages
     gateway: {
         async startAccount(context) {
             const { monitorXYProvider } = await import("./monitor.js");
+            const { createXyAcpBindingManager } = await import("./acp-session-binding.js");
             const account = resolveXYConfig(context.cfg);
             context.setStatus?.({
                 accountId: context.accountId,
                 wsUrl: account.wsUrl,
             });
             context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl: ${account.wsUrl})`);
+            // Register ACP session binding adapter for this account.
+            // Enables sessions_spawn(runtime="acp") to bind subagent sessions
+            // to the current A2A conversation.
+            createXyAcpBindingManager({ accountId: context.accountId, cfg: context.cfg });
             return monitorXYProvider({
                 config: context.cfg,
                 runtime: context.runtime,

package/dist/src/client.d.ts

@@ -1,6 +1,11 @@
 import { XYWebSocketManager } from "./websocket.js";
 import type { XYChannelConfig } from "./types.js";
 import type { RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export declare function getCachedXYWebSocketManager(): XYWebSocketManager;
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/client.js

@@ -13,6 +13,16 @@ if (!_g.__xyWsManagerCache) {
     _g.__xyWsManagerCache = new Map();
 }
 const wsManagerCache = _g.__xyWsManagerCache;
+/**
+ * Get a cached WebSocket manager without requiring config.
+ * Returns the first available manager. Use when ALS has no SessionContext.
+ */
+export function getCachedXYWebSocketManager() {
+    if (wsManagerCache.size === 0) {
+        throw new Error("No WebSocket manager available in cache");
+    }
+    return wsManagerCache.values().next().value;
+}
 /**
  * Get or create a WebSocket manager for the given configuration.
  * Reuses existing managers if config matches.

package/dist/src/cron-command.d.ts

@@ -2,6 +2,8 @@ import type { XYChannelConfig, A2ACommand } from "./types.js";
 export interface SendCommandViaPushParams {
     config: XYChannelConfig;
     command: A2ACommand;
+    /** 指定设备的 pushId（多设备路由）。未传时回退到 getAllPushIds()[0]。 */
+    pushId?: string;
 }
 /**
  * Send a tool command through the push channel (for cron-triggered tool calls).

package/dist/src/cron-command.js

@@ -24,16 +24,22 @@ export async function sendCommandViaPush(params) {
         command.header?.name ??
         "Command";
     logger.log(`[CRON-CMD] Sending command via push, intent=${intentName}`);
-    // 1. Load push IDs, use first one
+    // 1. 选 pushId：优先用调用方解析出的设备 pushId（多设备路由正确）；
+    //    未提供时回退到 getAllPushIds()[0]（单设备兼容旧行为）。
     let pushId = config.pushId;
-    try {
-        const pushIdList = await getAllPushIds();
-        if (pushIdList.length > 0) {
-            pushId = pushIdList[0];
-        }
+    if (params.pushId) {
+        pushId = params.pushId;
     }
-    catch (error) {
-        logger.error("[CRON-CMD] Failed to load pushIds:", error);
+    else {
+        try {
+            const pushIdList = await getAllPushIds();
+            if (pushIdList.length > 0) {
+                pushId = pushIdList[0];
+            }
+        }
+        catch (error) {
+            logger.error("[CRON-CMD] Failed to load pushIds:", error);
+        }
     }
     // 2. Build and send push notification with command in directives
     const pushService = new XYPushService(config);

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

@@ -7,6 +7,8 @@ import { callGatewayTool } from "openclaw/plugin-sdk/agent-harness-runtime";
 import * as os from "os";
 import { sendCommand } from "./formatter.js";
 import { resolveXYConfig } from "./config.js";
+import { configManager } from "./utils/config-manager.js";
+import { setJobPushId } from "./utils/cron-push-map.js";
 import { logger } from "./utils/logger.js";
 import { readFileSync, readdirSync } from "fs";
 import { join } from "path";
@@ -19,7 +21,8 @@ const GATEWAY_TIMEOUT_MS = 60_000;
  */
 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)"}`);
+    const log = logger.withContext(sessionId ?? "", taskId ?? "");
+    log.log(`[CRON-QUERY] Received event: action=${action}, jobId=${jobId ?? "(none)"}`);
     let result;
     let error;
     try {
@@ -38,6 +41,11 @@ export async function handleCronQueryEvent(context, cfg) {
                 break;
             case "add":
                 result = await callGatewayTool("cron.add", { timeoutMs: GATEWAY_TIMEOUT_MS }, params ?? {});
+                // 捕获 jobId↔pushId：cron-query 路径由 channel 自己建 job，
+                // 此处 context 握着 sessionId，configManager 有对应设备 pushId。
+                await persistCronPushMap(context.sessionId, result).catch((err) => {
+                    logger.error(`[CRON-QUERY] Failed to persist cron-push-map:`, err);
+                });
                 break;
             case "update":
                 result = await callGatewayTool("cron.update", { timeoutMs: GATEWAY_TIMEOUT_MS }, {
@@ -62,17 +70,17 @@ export async function handleCronQueryEvent(context, cfg) {
                 break;
             default:
                 error = `Unknown action: ${context.action}`;
-                logger.error(`[CRON-QUERY] ${error}`);
+                log.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);
+        log.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)}`);
+    log.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 {
@@ -93,17 +101,46 @@ export async function handleCronQueryEvent(context, cfg) {
                 taskId,
                 messageId,
                 command,
-                final: false,
+                final: sessionId.toLowerCase().endsWith("cronquery"),
             });
-            logger.log(`[CRON-QUERY] Sent response via sendCommand, action=${action}`);
+            log.log(`[CRON-QUERY] Sent response via sendCommand, action=${action}`);
         }
         catch (sendErr) {
-            logger.error(`[CRON-QUERY] Failed to send response via sendCommand:`, sendErr);
+            log.error(`[CRON-QUERY] Failed to send response via sendCommand:`, sendErr);
         }
     }
     else {
-        logger.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+        log.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+    }
+}
+/**
+ * 从 cron.add 结果中提取 jobId，配合 sessionId 对应的 pushId 写入映射。
+ */
+async function persistCronPushMap(sessionId, result) {
+    logger.log(`[CRONMAP] cron-query persist: sessionId=${sessionId ?? "(none)"}, resultType=${typeof result}`);
+    if (!sessionId) {
+        logger.log(`[CRONMAP] cron-query skip: no sessionId in context`);
+        return;
+    }
+    let jobId;
+    if (result && typeof result === "object") {
+        const id = result.id;
+        if (typeof id === "string" && id.trim())
+            jobId = id.trim();
+    }
+    if (!jobId) {
+        const preview = typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result)?.slice(0, 200);
+        logger.log(`[CRONMAP] cron-query skip: no jobId in result. preview=${preview ?? "(empty)"}`);
+        return;
+    }
+    const pushId = configManager.getPushId(sessionId);
+    if (!pushId) {
+        logger.log(`[CRONMAP] cron-query skip: configManager has no pushId for sessionId=${sessionId}`);
+        return;
     }
+    logger.log(`[CRONMAP] cron-query writing map: jobId=${jobId}, pushId=${pushId.substring(0, 16)}...`);
+    await setJobPushId(jobId, { pushId, sessionId, source: "cron-query" });
+    logger.log(`[CRONMAP] cron-query map written OK`);
 }
 /**
  * Read local cron folder directly (bypassing openclaw RPC) and return

package/dist/src/cspl/call_api.js

@@ -4,7 +4,8 @@
 import https from 'https';
 import { URL } from 'url';
 import { getConfig } from './config.js';
-import { DEFAULT_HTTP_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+import { DEFAULT_HTTPS_PORT, HTTP_STATUS_BAD_REQUEST, API_URL_SUFFIX } from './constants.js';
+import { logger } from '../utils/logger.js';
 function buildHeadersForCelia(config, sessionId) {
     if (!config.uid || !config.apiKey || !config.skillId || !config.requestFrom) {
         throw new Error('[SENTINEL HOOK] Missing required configuration: uid, apiKey, skillId, or requestFrom is not defined');
@@ -22,7 +23,7 @@ function buildRequestOptions(url, headers, timeout) {
     const urlObj = new URL(url);
     return {
         hostname: urlObj.hostname,
-        port: urlObj.port || DEFAULT_HTTP_PORT,
+        port: urlObj.port || DEFAULT_HTTPS_PORT,
         path: urlObj.pathname,
         method: "POST",
         headers: headers,
@@ -89,6 +90,7 @@ export async function callApi(questionText, api, sessionId, action) {
     };
     const httpBody = JSON.stringify(payload);
     const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    logger.log(`[SENTINEL HOOK] callApi: action=${action}, x-hag-trace-id=${sessionId}, url=${apiUrl}`);
     return new Promise((resolve, reject) => {
         const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
         const req = https.request(options, (res) => {

package/dist/src/cspl/sentinel_hook.js

@@ -6,15 +6,16 @@ import { callApi } from './call_api.js';
 import { processText, extractResultText, validateAndTruncateText, parseSecurityResult, handleExecToolInput, handleMessageToolInput, handleOtherToolInput } from './utils.js';
 import { ALLOWED_TOOLS, MAX_TEXT_LENGTH, MAX_TOTAL_LENGTH, MIN_TEXT_LENGTH, STEER_ABORT_MESSAGE, TOOL_OUTPUT_ACTION } from './constants.js';
 import { logger } from '../utils/logger.js';
-import { getSessionContext } from '../tools/session-manager.js';
+import { getCurrentSessionContext } from '../tools/session-manager.js';
 import { tryInjectSteer } from './steer-context.js';
 // 主入口模块
 export default function register(api) {
     api.on("before_tool_call", async (event, ctx) => {
         logger.log(`[SENTINEL HOOK] before_tool_call_event toolName: ${event.toolName}`);
-        // 生成sessionID
-        const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-        logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+        // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+        const sessionCtx = getCurrentSessionContext();
+        const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+        logger.log(`[SENTINEL HOOK] Session ID: ${sessionId} (fromALS: ${!!sessionCtx?.sessionId})`);
         // 处理 TOOL_INPUT 数据采集、发送数据，根据扫描结果决定是否阻塞
         try {
             let scanResult = null;
@@ -43,9 +44,10 @@ export default function register(api) {
         }
         try {
             logger.log(`[SENTINEL HOOK] after_tool_call_event toolName: ${event.toolName}`);
-            // 生成sessionID
-            const sessionId = (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
-            logger.log(`[SENTINEL HOOK] Generated Session ID: ${sessionId}`);
+            // 获取真实sessionID：优先使用ALS中的A2A sessionId，降级到OpenClaw runId或随机值
+            const sessionCtx = getCurrentSessionContext();
+            const sessionId = sessionCtx?.sessionId || (event.runId?.replace(/-/g, '') || crypto.randomBytes(16).toString('hex'));
+            logger.log(`[SENTINEL HOOK] Session ID: ${sessionId} (fromALS: ${!!sessionCtx?.sessionId})`);
             // 处理TOOL_OUTPUT数据采集（保持现有逻辑）
             const resultText = extractResultText(event, event.toolName);
             const resultTextLength = resultText.length;
@@ -78,7 +80,6 @@ export default function register(api) {
                 logger.log(`[SENTINEL HOOK] TOOL_OUTPUT response: status=${result.status}.`);
                 if (result.status === 'REJECT') {
                     logger.warn('[SENTINEL HOOK] REJECT detected, attempting steer injection');
-                    const sessionCtx = ctx.sessionKey ? getSessionContext(ctx.sessionKey) : null;
                     if (sessionCtx?.sessionId && sessionCtx?.taskId) {
                         await tryInjectSteer({
                             sessionId: sessionCtx.sessionId,

package/dist/src/cspl/upload_file.js

@@ -6,7 +6,7 @@ import path from 'path';
 import https from 'https';
 import { URL } from 'url';
 import { getConfig } from './config.js';
-import { DEFAULT_HTTP_PORT, DEFAULT_HTTPS_PORT, MAX_TIMES, CONNECT_TIMEOUT, READ_TIMEOUT, EXPIRE_TIME, OSMS_PREPARE_URL, OSMS_COMPLETE_URL, TEMPORARY_MATERIAL_PACKAGE, FILE_OWNER_UID, FILE_OWNER_TEAM_ID } from './constants.js';
+import { DEFAULT_HTTPS_PORT, MAX_TIMES, CONNECT_TIMEOUT, READ_TIMEOUT, EXPIRE_TIME, OSMS_PREPARE_URL, OSMS_COMPLETE_URL, TEMPORARY_MATERIAL_PACKAGE, FILE_OWNER_UID, FILE_OWNER_TEAM_ID } from './constants.js';
 function buildOsmsHeaders(config, traceId) {
     return {
         'content-type': 'application/json',
@@ -22,7 +22,7 @@ function httpRequest(url, method, headers, body, timeout) {
         const urlObj = new URL(url);
         const options = {
             hostname: urlObj.hostname,
-            port: urlObj.port || DEFAULT_HTTP_PORT,
+            port: urlObj.port || DEFAULT_HTTPS_PORT,
             path: urlObj.pathname + urlObj.search,
             method: method,
             headers: headers,