@ynhcj/xiaoyi 2.5.5 → 2.5.7

package/dist/config-schema.d.ts

@@ -8,8 +8,10 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     /** Whether this channel is enabled */
     enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** WebSocket URL for A2A connection */
-    wsUrl: z.ZodOptional<z.ZodString>;
+    /** First WebSocket server URL */
+    wsUrl1: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Second WebSocket server URL */
+    wsUrl2: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     /** Access Key for authentication */
     ak: z.ZodOptional<z.ZodString>;
     /** Secret Key for authentication */
@@ -18,27 +20,25 @@ export declare const XiaoYiConfigSchema: z.ZodObject<{
     agentId: z.ZodOptional<z.ZodString>;
     /** Enable debug logging */
     debug: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    /** Enable streaming responses (default: false) */
-    enableStreaming: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     /** Multi-account configuration */
     accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     enabled?: boolean;
-    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak?: string;
     sk?: string;
     agentId?: string;
-    enableStreaming?: boolean;
     name?: string;
     debug?: boolean;
     accounts?: Record<string, unknown>;
 }, {
     enabled?: boolean;
-    wsUrl?: string;
+    wsUrl1?: string;
+    wsUrl2?: string;
     ak?: string;
     sk?: string;
     agentId?: string;
-    enableStreaming?: boolean;
     name?: string;
     debug?: boolean;
     accounts?: Record<string, unknown>;

package/dist/config-schema.js

@@ -10,9 +10,11 @@ exports.XiaoYiConfigSchema = zod_1.z.object({
     /** Account name (optional display name) */
     name: zod_1.z.string().optional(),
     /** Whether this channel is enabled */
-    enabled: zod_1.z.boolean().optional().default(true),
-    /** WebSocket URL for A2A connection */
-    wsUrl: zod_1.z.string().optional(),
+    enabled: zod_1.z.boolean().optional().default(false),
+    /** First WebSocket server URL */
+    wsUrl1: zod_1.z.string().optional().default("wss://hag.cloud.huawei.com/openclaw/v1/ws/link"),
+    /** Second WebSocket server URL */
+    wsUrl2: zod_1.z.string().optional().default("wss://116.63.174.231/openclaw/v1/ws/link"),
     /** Access Key for authentication */
     ak: zod_1.z.string().optional(),
     /** Secret Key for authentication */
@@ -21,8 +23,6 @@ exports.XiaoYiConfigSchema = zod_1.z.object({
     agentId: zod_1.z.string().optional(),
     /** Enable debug logging */
     debug: zod_1.z.boolean().optional().default(false),
-    /** Enable streaming responses (default: false) */
-    enableStreaming: zod_1.z.boolean().optional().default(false),
     /** Multi-account configuration */
     accounts: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
 });

package/dist/file-download.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Download a file from URL to local path.
+ */
+export declare function downloadFile(url: string, destPath: string): Promise<void>;
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+export declare function downloadFilesFromParts(fileParts: Array<{
+    name: string;
+    mimeType: string;
+    uri: string;
+}>, tempDir?: string): Promise<Array<{
+    path: string;
+    name: string;
+    mimeType: string;
+}>>;

package/dist/file-download.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+exports.downloadFilesFromParts = downloadFilesFromParts;
+// File download utilities
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const logger_js_1 = require("./xy-utils/logger.js");
+/**
+ * Download a file from URL to local path.
+ */
+async function downloadFile(url, destPath) {
+    logger_js_1.logger.debug(`Downloading file from ${url} to ${destPath}`);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 30000); // 30 seconds timeout
+    try {
+        const response = await (0, node_fetch_1.default)(url, { signal: controller.signal });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await promises_1.default.writeFile(destPath, buffer);
+        logger_js_1.logger.debug(`File downloaded successfully: ${destPath}`);
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            logger_js_1.logger.error(`Download timeout (30s) for ${url}`);
+            throw new Error(`Download timeout after 30 seconds`);
+        }
+        logger_js_1.logger.error(`Failed to download file from ${url}:`, error);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_channel") {
+    // Create temp directory if it doesn't exist
+    await promises_1.default.mkdir(tempDir, { recursive: true });
+    const downloadedFiles = [];
+    for (const filePart of fileParts) {
+        const { name, mimeType, uri } = filePart;
+        // Generate safe file name
+        const safeName = name.replace(/[^a-zA-Z0-9._-]/g, "_");
+        const destPath = path_1.default.join(tempDir, `${Date.now()}_${safeName}`);
+        try {
+            await downloadFile(uri, destPath);
+            downloadedFiles.push({
+                path: destPath,
+                name,
+                mimeType,
+            });
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to download file ${name}:`, error);
+            // Continue with other files
+        }
+    }
+    return downloadedFiles;
+}

package/dist/heartbeat.d.ts

@@ -0,0 +1,39 @@
+import WebSocket from "ws";
+export interface HeartbeatConfig {
+    interval: number;
+    timeout: number;
+    message: string;
+}
+/**
+ * Manages heartbeat for a WebSocket connection.
+ * Supports both application-level and protocol-level heartbeats.
+ */
+export declare class HeartbeatManager {
+    private ws;
+    private config;
+    private onTimeout;
+    private serverName;
+    private onHeartbeatSuccess?;
+    private intervalTimer;
+    private timeoutTimer;
+    private lastPongTime;
+    private log;
+    private error;
+    constructor(ws: WebSocket, config: HeartbeatConfig, onTimeout: () => void, serverName?: string, logFn?: (msg: string, ...args: any[]) => void, errorFn?: (msg: string, ...args: any[]) => void, onHeartbeatSuccess?: () => void);
+    /**
+     * Start heartbeat monitoring.
+     */
+    start(): void;
+    /**
+     * Stop heartbeat monitoring.
+     */
+    stop(): void;
+    /**
+     * Send a heartbeat ping.
+     */
+    private sendHeartbeat;
+    /**
+     * Check if connection is healthy based on last pong time.
+     */
+    isHealthy(): boolean;
+}

package/dist/heartbeat.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeartbeatManager = void 0;
+// Heartbeat management for WebSocket connections
+const ws_1 = __importDefault(require("ws"));
+/**
+ * Manages heartbeat for a WebSocket connection.
+ * Supports both application-level and protocol-level heartbeats.
+ */
+class HeartbeatManager {
+    constructor(ws, config, onTimeout, serverName = "unknown", logFn, errorFn, onHeartbeatSuccess // ✅ 心跳成功回调，向 OpenClaw 报告健康状态
+    ) {
+        this.ws = ws;
+        this.config = config;
+        this.onTimeout = onTimeout;
+        this.serverName = serverName;
+        this.onHeartbeatSuccess = onHeartbeatSuccess;
+        this.intervalTimer = null;
+        this.timeoutTimer = null;
+        this.lastPongTime = 0;
+        this.log = logFn ?? console.log;
+        this.error = errorFn ?? console.error;
+    }
+    /**
+     * Start heartbeat monitoring.
+     */
+    start() {
+        this.stop(); // Clear any existing timers
+        this.lastPongTime = Date.now();
+        // Setup ping/pong for protocol-level heartbeat
+        this.ws.on("pong", () => {
+            this.lastPongTime = Date.now();
+            if (this.timeoutTimer) {
+                clearTimeout(this.timeoutTimer);
+                this.timeoutTimer = null;
+            }
+            // ✅ Report health: heartbeat successful - notify OpenClaw framework
+            this.onHeartbeatSuccess?.();
+            this.log(`[${this.serverName}] Heartbeat pong received, health reported to OpenClaw`);
+        });
+        // Start interval timer
+        this.intervalTimer = setInterval(() => {
+            this.sendHeartbeat();
+        }, this.config.interval);
+        this.log(`[${this.serverName}] Heartbeat started: interval=${this.config.interval}ms, timeout=${this.config.timeout}ms`);
+    }
+    /**
+     * Stop heartbeat monitoring.
+     */
+    stop() {
+        if (this.intervalTimer) {
+            clearInterval(this.intervalTimer);
+            this.intervalTimer = null;
+        }
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+            this.timeoutTimer = null;
+        }
+        // Remove pong listener
+        this.ws.off("pong", () => { });
+        this.log(`[${this.serverName}] Heartbeat stopped`);
+    }
+    /**
+     * Send a heartbeat ping.
+     */
+    sendHeartbeat() {
+        if (this.ws.readyState !== ws_1.default.OPEN) {
+            console.warn(`[${this.serverName}] Cannot send heartbeat: WebSocket not open`);
+            return;
+        }
+        try {
+            // Send application-level heartbeat message
+            this.log(`[${this.serverName}] Sending heartbeat frame:`, this.config.message.substring(0, 100));
+            this.ws.send(this.config.message);
+            // Send protocol-level ping
+            this.ws.ping();
+            this.log(`[${this.serverName}] Protocol-level ping sent`);
+            // Setup timeout timer
+            this.timeoutTimer = setTimeout(() => {
+                this.error(`[${this.serverName}] Heartbeat timeout - no pong received`);
+                this.onTimeout();
+            }, this.config.timeout);
+        }
+        catch (error) {
+            this.error(`[${this.serverName}] Failed to send heartbeat:`, error);
+        }
+    }
+    /**
+     * Check if connection is healthy based on last pong time.
+     */
+    isHealthy() {
+        if (this.lastPongTime === 0) {
+            return true; // Not started yet
+        }
+        const timeSinceLastPong = Date.now() - this.lastPongTime;
+        return timeSinceLastPong < this.config.interval + this.config.timeout;
+    }
+}
+exports.HeartbeatManager = HeartbeatManager;

package/dist/index.d.ts

@@ -14,13 +14,10 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
  *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id",
- *       "enableStreaming": true
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }
- *
- * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 declare const plugin: {
     id: string;

package/dist/index.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const plugin_sdk_1 = require("openclaw/plugin-sdk");
-const channel_1 = require("./channel");
-const runtime_1 = require("./runtime");
+const channel_js_1 = require("./channel.js");
+const runtime_js_1 = require("./runtime.js");
 /**
  * XiaoYi Channel Plugin for OpenClaw
  *
@@ -18,26 +17,23 @@ const runtime_1 = require("./runtime");
  *       "wsUrl2": "ws://localhost:8766/ws/link",
  *       "ak": "test_ak",
  *       "sk": "test_sk",
- *       "agentId": "your-agent-id",
- *       "enableStreaming": true
+ *       "agentId": "your-agent-id"
  *     }
  *   }
  * }
- *
- * Backward compatibility: Can use "wsUrl" instead of "wsUrl1" (wsUrl2 will use default)
  */
 const plugin = {
     id: "xiaoyi",
     name: "XiaoYi Channel",
     description: "XiaoYi channel plugin with A2A protocol support",
-    configSchema: (0, plugin_sdk_1.emptyPluginConfigSchema)(),
+    configSchema: undefined,
     register(api) {
         console.log("XiaoYi: register() called - START");
         // Set runtime for managing WebSocket connections
-        (0, runtime_1.setXiaoYiRuntime)(api.runtime);
+        (0, runtime_js_1.setXiaoYiRuntime)(api.runtime);
         console.log("XiaoYi: setXiaoYiRuntime() completed");
         // Clean up any existing connections from previous plugin loads
-        const runtime = require("./runtime").getXiaoYiRuntime();
+        const runtime = require("./runtime.js").getXiaoYiRuntime();
         console.log(`XiaoYi: Got runtime instance: ${runtime.getInstanceId()}, isConnected: ${runtime.isConnected()}`);
         if (runtime.isConnected()) {
             console.log("XiaoYi: Cleaning up existing connection from previous load");
@@ -45,7 +41,7 @@ const plugin = {
         }
         // Register the channel plugin
         console.log("XiaoYi: About to call registerChannel()");
-        api.registerChannel({ plugin: channel_1.xiaoyiPlugin });
+        api.registerChannel({ plugin: channel_js_1.xiaoyiPlugin });
         console.log("XiaoYi: registerChannel() completed");
         console.log("XiaoYi channel plugin registered - END");
     },

package/dist/push.d.ts

@@ -0,0 +1,28 @@
+import { XiaoYiChannelConfig } from "./types.js";
+/**
+ * Push message sending service
+ * Sends notifications to XiaoYi clients via webhook API
+ */
+export declare class XiaoYiPushService {
+    private config;
+    private readonly pushUrl;
+    constructor(config: XiaoYiChannelConfig);
+    /**
+     * Check if push functionality is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Generate HMAC-SHA256 signature
+     */
+    private generateSignature;
+    /**
+     * Generate UUID
+     */
+    private generateUUID;
+    /**
+     * Send push notification (with summary text)
+     * @param text - Summary text to send (e.g., first 30 characters)
+     * @param pushText - Push notification message (e.g., "任务已完成：xxx...")
+     */
+    sendPush(text: string, pushText: string): Promise<boolean>;
+}

package/dist/push.js

@@ -0,0 +1,135 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XiaoYiPushService = void 0;
+const crypto = __importStar(require("crypto"));
+/**
+ * Push message sending service
+ * Sends notifications to XiaoYi clients via webhook API
+ */
+class XiaoYiPushService {
+    constructor(config) {
+        this.pushUrl = "https://hag.cloud.huawei.com/open-ability-agent/v1/agent-webhook";
+        this.config = config;
+    }
+    /**
+     * Check if push functionality is configured
+     */
+    isConfigured() {
+        return Boolean(this.config.apiId?.trim() &&
+            this.config.pushId?.trim() &&
+            this.config.ak?.trim() &&
+            this.config.sk?.trim());
+    }
+    /**
+     * Generate HMAC-SHA256 signature
+     */
+    generateSignature(timestamp) {
+        const hmac = crypto.createHmac("sha256", this.config.sk);
+        hmac.update(timestamp);
+        return hmac.digest().toString("base64");
+    }
+    /**
+     * Generate UUID
+     */
+    generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+    /**
+     * Send push notification (with summary text)
+     * @param text - Summary text to send (e.g., first 30 characters)
+     * @param pushText - Push notification message (e.g., "任务已完成：xxx...")
+     */
+    async sendPush(text, pushText) {
+        if (!this.isConfigured()) {
+            console.log("[PUSH] Push not configured, skipping");
+            return false;
+        }
+        try {
+            const timestamp = Date.now().toString();
+            const signature = this.generateSignature(timestamp);
+            const messageId = this.generateUUID();
+            const payload = {
+                jsonrpc: "2.0",
+                id: messageId,
+                result: {
+                    id: this.generateUUID(),
+                    apiId: this.config.apiId,
+                    pushId: this.config.pushId,
+                    pushText: pushText,
+                    kind: "task",
+                    artifacts: [{
+                            artifactId: this.generateUUID(),
+                            parts: [{
+                                    kind: "text",
+                                    text: text, // Summary text
+                                }]
+                        }],
+                    status: { state: "completed" }
+                }
+            };
+            console.log(`[PUSH] Sending push notification: ${pushText}`);
+            const response = await fetch(this.pushUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Accept": "application/json",
+                    "x-hag-trace-id": this.generateUUID(),
+                    "X-Access-Key": this.config.ak,
+                    "X-Sign": signature,
+                    "X-Ts": timestamp,
+                },
+                body: JSON.stringify(payload),
+            });
+            if (response.ok) {
+                console.log("[PUSH] Push notification sent successfully");
+                return true;
+            }
+            else {
+                console.error(`[PUSH] Failed: HTTP ${response.status}`);
+                return false;
+            }
+        }
+        catch (error) {
+            console.error("[PUSH] Error:", error);
+            return false;
+        }
+    }
+}
+exports.XiaoYiPushService = XiaoYiPushService;

package/dist/runtime.d.ts

@@ -1,5 +1,5 @@
-import { XiaoYiWebSocketManager } from "./websocket";
-import { XiaoYiChannelConfig } from "./types";
+import { XiaoYiWebSocketManager } from "./websocket.js";
+import { XiaoYiChannelConfig } from "./types.js";
 /**
  * Timeout configuration
  */
@@ -23,6 +23,11 @@ export declare class XiaoYiRuntime {
     private timeoutConfig;
     private sessionAbortControllerMap;
     private sessionActiveRunMap;
+    private sessionStartTimeMap;
+    private static readonly SESSION_STALE_TIMEOUT_MS;
+    private sessionTaskTimeoutMap;
+    private sessionPushPendingMap;
+    private taskTimeoutMs;
     constructor();
     getInstanceId(): string;
     /**
@@ -115,6 +120,7 @@ export declare class XiaoYiRuntime {
     } | null;
     /**
      * Check if a session has an active agent run
+     * If session is active but stale (超过 SESSION_STALE_TIMEOUT_MS), automatically clean up
      * @param sessionId - Session ID
      * @returns true if session is busy
      */
@@ -140,6 +146,46 @@ export declare class XiaoYiRuntime {
      * Clear all AbortControllers
      */
     clearAllAbortControllers(): void;
+    /**
+     * Generate a composite key for session+task combination
+     * This ensures each task has its own push state, even within the same session
+     */
+    private getPushStateKey;
+    /**
+     * Set task timeout time (from configuration)
+     */
+    setTaskTimeout(timeoutMs: number): void;
+    /**
+     * Set a 1-hour task timeout timer for a session
+     * @returns timeout ID
+     */
+    setTaskTimeoutForSession(sessionId: string, taskId: string, callback: (sessionId: string, taskId: string) => void): NodeJS.Timeout;
+    /**
+     * Clear the task timeout timer for a session
+     */
+    clearTaskTimeoutForSession(sessionId: string): void;
+    /**
+     * Check if session+task is waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    isSessionWaitingForPush(sessionId: string, taskId?: string): boolean;
+    /**
+     * Mark session+task as waiting for push notification
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    markSessionWaitingForPush(sessionId: string, taskId?: string): void;
+    /**
+     * Clear the waiting push state for a session+task
+     * @param sessionId - Session ID
+     * @param taskId - Task ID (optional, for per-task tracking)
+     */
+    clearSessionWaitingForPush(sessionId: string, taskId?: string): void;
+    /**
+     * Clear all task timeout related state for a session
+     */
+    clearTaskTimeoutState(sessionId: string): void;
 }
 export declare function getXiaoYiRuntime(): XiaoYiRuntime;
 export declare function setXiaoYiRuntime(runtime: any): void;