@ynhcj/xiaoyi-channel 1.1.26 → 1.1.28

package/dist/src/client.js

@@ -24,10 +24,10 @@ export function getXYWebSocketManager(config, runtime) {
         return cached;
     }
     // Create new manager
-    logger.log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    logger.log(`[WS-MANAGER-CACHE] Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
     cached = new XYWebSocketManager(config, runtime);
     wsManagerCache.set(cacheKey, cached);
-    logger.log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
+    logger.log(`[WS-MANAGER-CACHE] Total managers after creation: ${wsManagerCache.size}`);
     return cached;
 }
 /**
@@ -38,13 +38,13 @@ export function removeXYWebSocketManager(config) {
     const cacheKey = `${config.apiKey}-${config.agentId}`;
     const manager = wsManagerCache.get(cacheKey);
     if (manager) {
-        logger.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        logger.log(`[WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
         manager.disconnect();
         wsManagerCache.delete(cacheKey);
-        logger.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+        logger.log(`[WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
     }
     else {
-        logger.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+        logger.log(`[WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
     }
 }
 /**
@@ -68,35 +68,25 @@ export function getCachedManagerCount() {
  * Helps identify connection issues and orphan connections.
  */
 export function diagnoseAllManagers() {
-    logger.log(`Total cached managers: ${wsManagerCache.size}`);
+    logger.log(`[DIAG] Total cached managers: ${wsManagerCache.size}`);
     if (wsManagerCache.size === 0) {
-        logger.log("ℹ️  No managers in cache");
+        logger.log("[DIAG] No managers in cache");
         return;
     }
     let orphanCount = 0;
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
-        logger.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
-        // Connection
-        logger.log(`   🔌 Connection:`);
-        logger.log(`      - Exists: ${diag.connection.exists}`);
-        logger.log(`      - ReadyState: ${diag.connection.readyState}`);
-        logger.log(`      - State connected/ready: ${diag.connection.stateConnected}/${diag.connection.stateReady}`);
-        logger.log(`      - Reconnect attempts: ${diag.connection.reconnectAttempts}`);
-        logger.log(`      - Listeners on WebSocket: ${diag.connection.listenerCount}`);
-        logger.log(`      - Heartbeat active: ${diag.connection.heartbeatActive}`);
-        logger.log(`      - Has reconnect timer: ${diag.connection.hasReconnectTimer}`);
+        logger.log(`[DIAG] Manager ${key} — event listeners: ${diag.totalEventListeners} | Connection: exists=${diag.connection.exists}, readyState=${diag.connection.readyState}, stateConnected=${diag.connection.stateConnected}/${diag.connection.stateReady}, reconnectAttempts=${diag.connection.reconnectAttempts}, wsListeners=${diag.connection.listenerCount}, heartbeatActive=${diag.connection.heartbeatActive}, hasReconnectTimer=${diag.connection.hasReconnectTimer}`);
         if (diag.connection.isOrphan) {
-            logger.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            logger.log(`[DIAG] ORPHAN CONNECTION DETECTED on manager: ${key}`);
             orphanCount++;
         }
     });
     if (orphanCount > 0) {
-        logger.log(`⚠️  Total orphan connections found: ${orphanCount}`);
-        logger.log(`💡 Suggestion: These connections should be cleaned up`);
+        logger.log(`[DIAG] Total orphan connections found: ${orphanCount} — these connections should be cleaned up`);
     }
     else {
-        logger.log(`✅ No orphan connections found`);
+        logger.log("[DIAG] No orphan connections found");
     }
 }
 /**
@@ -108,13 +98,13 @@ export function cleanupOrphanConnections() {
     wsManagerCache.forEach((manager, key) => {
         const diag = manager.getConnectionDiagnostics();
         if (diag.connection.isOrphan) {
-            logger.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            logger.log(`[CLEANUP] Cleaning up orphan connections in manager: ${key}`);
             manager.disconnect();
             cleanedCount++;
         }
     });
     if (cleanedCount > 0) {
-        logger.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+        logger.log(`[CLEANUP] Cleaned up ${cleanedCount} manager(s) with orphan connections`);
     }
     return cleanedCount;
 }

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

@@ -0,0 +1,15 @@
+import type { XYChannelConfig, A2ACommand } from "./types.js";
+export interface SendCommandViaPushParams {
+    config: XYChannelConfig;
+    command: A2ACommand;
+}
+/**
+ * Send a tool command through the push channel (for cron-triggered tool calls).
+ *
+ * Flow:
+ *  1. Push notification is sent with command embedded in data.directives
+ *  2. Device receives push → extracts directives → executes command
+ *  3. Device returns result via WebSocket (data-event / gui-agent-response / …)
+ *  4. The calling tool listens on the WebSocket manager as usual
+ */
+export declare function sendCommandViaPush(params: SendCommandViaPushParams): Promise<void>;

package/dist/src/cron-command.js

@@ -0,0 +1,49 @@
+// Cron-triggered tool command delivery via push channel.
+// When a cron/scheduled task executes a tool, there is no active WebSocket
+// session to carry the command. Instead, the command is delivered through
+// the push notification channel (agent-webhook), which reaches the device
+// independently of any session. The device processes the command and returns
+// results through the normal WebSocket connection, so response listening
+// works the same as for regular tool calls.
+import { randomUUID } from "crypto";
+import { XYPushService } from "./push.js";
+import { getAllPushIds } from "./utils/pushid-manager.js";
+import { logger } from "./utils/logger.js";
+/**
+ * Send a tool command through the push channel (for cron-triggered tool calls).
+ *
+ * Flow:
+ *  1. Push notification is sent with command embedded in data.directives
+ *  2. Device receives push → extracts directives → executes command
+ *  3. Device returns result via WebSocket (data-event / gui-agent-response / …)
+ *  4. The calling tool listens on the WebSocket manager as usual
+ */
+export async function sendCommandViaPush(params) {
+    const { config, command } = params;
+    const intentName = command.payload?.executeParam?.intentName ??
+        command.header?.name ??
+        "Command";
+    logger.log(`[CRON-CMD] Sending command via push, intent=${intentName}`);
+    // 1. Load push IDs, use first one
+    let pushId = config.pushId;
+    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);
+    const sessionId = randomUUID();
+    try {
+        await pushService.sendPushWithDirectives(pushId, sessionId, [command]);
+        logger.log(`[CRON-CMD] Push sent successfully, intent=${intentName}`);
+    }
+    catch (error) {
+        logger.error(`[CRON-CMD] Failed to send push`, error);
+        throw error;
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * 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: any, cfg: any): Promise<void>;

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

@@ -0,0 +1,189 @@
+// 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 * as os from "os";
+import { sendCommand } from "./formatter.js";
+import { resolveXYConfig } from "./config.js";
+import { logger } from "./utils/logger.js";
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+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;
+    const log = logger.withContext(sessionId ?? "", taskId ?? "");
+    log.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;
+            case "queryTimeList":
+                result = await queryTimeListLocal();
+                break;
+            default:
+                error = `Unknown action: ${context.action}`;
+                log.error(`[CRON-QUERY] ${error}`);
+                result = { error };
+        }
+    }
+    catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+        log.error(`[CRON-QUERY] RPC call failed for action=${action}:`, err);
+        result = { error };
+    }
+    // Log the result
+    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 {
+            const config = resolveXYConfig(cfg);
+            const command = {
+                header: {
+                    namespace: "AgentEvent",
+                    name: "CronQuery",
+                },
+                payload: {
+                    action,
+                    ans: result,
+                },
+            };
+            await sendCommand({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                command,
+                final: sessionId.toLowerCase().endsWith("cronquery"),
+            });
+            log.log(`[CRON-QUERY] Sent response via sendCommand, action=${action}`);
+        }
+        catch (sendErr) {
+            log.error(`[CRON-QUERY] Failed to send response via sendCommand:`, sendErr);
+        }
+    }
+    else {
+        log.warn(`[CRON-QUERY] Missing cfg/sessionId/taskId/messageId, skipping sendCommand`);
+    }
+}
+/**
+ * Read local cron folder directly (bypassing openclaw RPC) and return
+ * run records from the last 7 days, grouped by date and sorted by time.
+ *
+ * Data sources:
+ *   - state/cron/jobs.json   → job id → name mapping
+ *   - state/cron/runs/*.jsonl → run records (one JSON per line)
+ *
+ * Return format:
+ *   [ { "YYYY-MM-DD": [ { run record with .name }, ... ] }, ... ]
+ */
+async function queryTimeListLocal() {
+    const cronDir = join(os.homedir(), ".openclaw", "cron");
+    const jobsPath = join(cronDir, "jobs.json");
+    const runsDir = join(cronDir, "runs");
+    // 1. Build jobId → name map from jobs.json
+    const jobNameMap = {};
+    try {
+        const jobsRaw = readFileSync(jobsPath, "utf-8");
+        const jobsData = JSON.parse(jobsRaw);
+        for (const job of jobsData.jobs || []) {
+            jobNameMap[job.id] = job.name || job.id;
+        }
+    }
+    catch (err) {
+        logger.error(`[CRON-QUERY] Failed to read jobs.json: ${err.message}`);
+    }
+    // 2. Read all run files, collect runs within last 7 days
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    const allRuns = [];
+    let files = [];
+    try {
+        files = readdirSync(runsDir);
+    }
+    catch {
+        files = [];
+    }
+    for (const file of files) {
+        if (!file.endsWith(".jsonl"))
+            continue;
+        try {
+            const content = readFileSync(join(runsDir, file), "utf-8");
+            const lines = content.trim().split("\n");
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const run = JSON.parse(line);
+                    if (run.ts && run.ts >= sevenDaysAgo) {
+                        run.name = jobNameMap[run.jobId] || run.jobId || "";
+                        allRuns.push(run);
+                    }
+                }
+                catch {
+                    // skip malformed line
+                }
+            }
+        }
+        catch (err) {
+            logger.error(`[CRON-QUERY] Failed to read run file ${file}: ${err.message}`);
+        }
+    }
+    // 3. Sort by ts ascending
+    allRuns.sort((a, b) => a.ts - b.ts);
+    // 4. Group by date (YYYY-MM-DD in local time)
+    const grouped = new Map();
+    for (const run of allRuns) {
+        const d = new Date(run.ts);
+        const label = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+        if (!grouped.has(label)) {
+            grouped.set(label, []);
+        }
+        grouped.get(label).push(run);
+    }
+    // 5. Convert to ordered array of single-key objects
+    const result = [];
+    for (const [date, runs] of grouped) {
+        result.push({ [date]: runs });
+    }
+    return result;
+}

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

@@ -0,0 +1,2 @@
+import { ApiResponse } from './constants.js';
+export declare function callApi(questionText: string, api: any, sessionId: string, action: string): Promise<ApiResponse>;

package/dist/src/cspl/call_api.js

@@ -0,0 +1,107 @@
+/*
+ * 版权所有 (c) 华为技术有限公司 2026-2026
+ */
+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';
+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');
+    }
+    return {
+        'x-hag-trace-id': sessionId,
+        'x-uid': config.uid,
+        'x-api-key': config.apiKey,
+        'x-request-from': config.requestFrom,
+        'x-skill-id': config.skillId,
+        'content-type': 'application/json'
+    };
+}
+function buildRequestOptions(url, headers, timeout) {
+    const urlObj = new URL(url);
+    return {
+        hostname: urlObj.hostname,
+        port: urlObj.port || DEFAULT_HTTP_PORT,
+        path: urlObj.pathname,
+        method: "POST",
+        headers: headers,
+        timeout: timeout
+    };
+}
+function checkHttpStatus(res) {
+    if (res.statusCode && res.statusCode >= HTTP_STATUS_BAD_REQUEST) {
+        throw new Error(`HTTP error! status: ${res.statusCode}`);
+    }
+}
+function parseResponseData(data) {
+    try {
+        if (data === undefined || data === null || data.trim() === '') {
+            throw new Error('API response data is empty or invalid');
+        }
+        const jsonData = JSON.parse(data);
+        if (jsonData.retCode && jsonData.retCode !== "0") {
+            const errorMsg = jsonData.retMsg || 'Unknown API error';
+            throw new Error(`API error: ${errorMsg}`);
+        }
+        if (!jsonData.retCode && jsonData.code) {
+            const errorMsg = jsonData.desc || 'Unknown backend error';
+            throw new Error(`Backend error: ${errorMsg}`);
+        }
+        return jsonData;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw new Error(`[SENTINEL HOOK] Failed to parse response：${e.message}`);
+        }
+        return data;
+    }
+}
+function handleResponse(res, resolve, reject) {
+    let data = '';
+    try {
+        checkHttpStatus(res);
+    }
+    catch (e) {
+        reject(e);
+    }
+    res.on('data', (chunk) => {
+        data += chunk;
+    });
+    res.on('end', () => {
+        try {
+            const result = parseResponseData(data);
+            resolve(result);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+export async function callApi(questionText, api, sessionId, action) {
+    const config = getConfig(api);
+    const headersForCelia = buildHeadersForCelia(config, sessionId);
+    const payload = {
+        questionText: questionText,
+        textSource: config.textSource,
+        action: action,
+        extra: `${JSON.stringify({ userId: config.uid })}`
+    };
+    const httpBody = JSON.stringify(payload);
+    const apiUrl = `${config.api.url}${API_URL_SUFFIX}`;
+    return new Promise((resolve, reject) => {
+        const options = buildRequestOptions(apiUrl, headersForCelia, config.api.timeout);
+        const req = https.request(options, (res) => {
+            handleResponse(res, resolve, reject);
+        });
+        req.on('error', (error) => {
+            reject(error);
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('[SENTINEL HOOK] Request timeout'));
+        });
+        req.write(httpBody);
+        req.end();
+    });
+}

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

@@ -1,11 +1,11 @@
-import type { ClawdbotConfig } from "openclaw/plugin-sdk";
-import type { XYChannelConfig } from "../types.js";
+import { HttpHeaders } from './constants.js';
 export interface ApiConfig {
     url: string;
     timeout: number;
 }
-export interface CsplConfig {
+export interface Config {
     api: ApiConfig;
+    headers?: HttpHeaders;
     uid: string;
     apiKey: string;
     skillId: string;
@@ -13,17 +13,4 @@ export interface CsplConfig {
     textSource: string;
     action: string;
 }
-/**
- * 构建 CSPL 配置。uid 和 apiKey 复用 XYChannelConfig，避免重复配置。
- * serviceUrl 从 .xiaoyienv 文件读取，skillId 写死在常量中。
- *
- * Accepts either ClawdbotConfig (legacy after_tool_call path) or
- * XYChannelConfig (AgentToolResultMiddleware path).  Config is cached
- * after the first successful call so subsequent calls can omit the arg.
- */
-export declare function getCsplConfig(cfg?: ClawdbotConfig): CsplConfig;
-/**
- * Initialize CSPL config from an already-resolved XYChannelConfig.
- * Used by AgentToolResultMiddleware which has session context but not ClawdbotConfig.
- */
-export declare function initCsplConfigFromXYConfig(xyConfig: XYChannelConfig): CsplConfig;
+export declare function getConfig(api: any): Config;