@ynhcj/xiaoyi 0.0.1-beta

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+/**
+ * XiaoYi Channel Plugin for OpenClaw
+ *
+ * This plugin enables integration with XiaoYi's A2A protocol via WebSocket.
+ * Supports dual server mode for high availability.
+ *
+ * Configuration example in openclaw.json:
+ * {
+ *   "channels": {
+ *     "xiaoyi": {
+ *       "enabled": true,
+ *       "wsUrl1": "ws://localhost:8765/ws/link",
+ *       "wsUrl2": "ws://localhost:8766/ws/link",
+ *       "ak": "test_ak",
+ *       "sk": "test_sk",
+ *       "agentId": "your-agent-id"
+ *     }
+ *   }
+ * }
+ */
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: any;
+    register(api: OpenClawPluginApi): void;
+};
+export default plugin;

package/dist/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const channel_js_1 = require("./channel.js");
+const runtime_js_1 = require("./runtime.js");
+/**
+ * XiaoYi Channel Plugin for OpenClaw
+ *
+ * This plugin enables integration with XiaoYi's A2A protocol via WebSocket.
+ * Supports dual server mode for high availability.
+ *
+ * Configuration example in openclaw.json:
+ * {
+ *   "channels": {
+ *     "xiaoyi": {
+ *       "enabled": true,
+ *       "wsUrl1": "ws://localhost:8765/ws/link",
+ *       "wsUrl2": "ws://localhost:8766/ws/link",
+ *       "ak": "test_ak",
+ *       "sk": "test_sk",
+ *       "agentId": "your-agent-id"
+ *     }
+ *   }
+ * }
+ */
+const plugin = {
+    id: "xiaoyi",
+    name: "XiaoYi Channel",
+    description: "XiaoYi channel plugin with A2A protocol support",
+    configSchema: undefined,
+    register(api) {
+        console.log("XiaoYi: register() called - START");
+        // Set runtime for managing WebSocket connections
+        (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.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");
+            runtime.stop();
+        }
+        // Register the channel plugin
+        console.log("XiaoYi: About to call registerChannel()");
+        api.registerChannel({ plugin: channel_js_1.xiaoyiPlugin });
+        console.log("XiaoYi: registerChannel() completed");
+        console.log("XiaoYi channel plugin registered - END");
+    },
+};
+exports.default = plugin;

package/dist/onboarding.d.ts

@@ -0,0 +1,6 @@
+/**
+ * XiaoYi onboarding adapter for CLI setup wizard.
+ */
+type ChannelOnboardingAdapter = any;
+export declare const xiaoyiOnboardingAdapter: ChannelOnboardingAdapter;
+export {};

package/dist/onboarding.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * XiaoYi onboarding adapter for CLI setup wizard.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xiaoyiOnboardingAdapter = void 0;
+const channel = "xiaoyi";
+/**
+ * Get XiaoYi channel config from OpenClaw config
+ */
+function getXiaoYiConfig(cfg) {
+    return cfg?.channels?.xiaoyi;
+}
+/**
+ * Check if XiaoYi is properly configured
+ */
+function isXiaoYiConfigured(config) {
+    if (!config) {
+        return false;
+    }
+    // Check required fields: ak, sk, agentId
+    // wsUrl1/wsUrl2 are optional (defaults will be used if not provided)
+    const hasAk = typeof config.ak === "string" && config.ak.trim().length > 0;
+    const hasSk = typeof config.sk === "string" && config.sk.trim().length > 0;
+    const hasAgentId = typeof config.agentId === "string" && config.agentId.trim().length > 0;
+    return hasAk && hasSk && hasAgentId;
+}
+/**
+ * Set XiaoYi channel configuration
+ */
+function setXiaoYiConfig(cfg, config) {
+    const existing = getXiaoYiConfig(cfg);
+    const merged = {
+        enabled: config.enabled ?? existing?.enabled ?? true,
+        wsUrl: config.wsUrl ?? existing?.wsUrl ?? "",
+        wsUrl1: config.wsUrl1 ?? existing?.wsUrl1 ?? "",
+        wsUrl2: config.wsUrl2 ?? existing?.wsUrl2 ?? "",
+        ak: config.ak ?? existing?.ak ?? "",
+        sk: config.sk ?? existing?.sk ?? "",
+        agentId: config.agentId ?? existing?.agentId ?? "",
+        enableStreaming: config.enableStreaming ?? existing?.enableStreaming ?? true,
+    };
+    return {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            xiaoyi: merged,
+        },
+    };
+}
+/**
+ * Note about XiaoYi setup
+ */
+async function noteXiaoYiSetupHelp(prompter) {
+    await prompter.note([
+        "XiaoYi (小艺) uses A2A protocol via WebSocket connection.",
+        "",
+        "Required credentials:",
+        "  - ak: Access Key for authentication",
+        "  - sk: Secret Key for authentication",
+        "  - agentId: Your agent identifier",
+        "",
+        "WebSocket URLs will use default values.",
+        "",
+        "Docs: https://docs.openclaw.ai/channels/xiaoyi",
+    ].join("\n"), "XiaoYi setup");
+}
+/**
+ * Prompt for Access Key
+ */
+async function promptAk(prompter, config) {
+    const existing = config?.ak ?? "";
+    return String(await prompter.text({
+        message: "XiaoYi Access Key (ak)",
+        initialValue: existing,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    })).trim();
+}
+/**
+ * Prompt for Secret Key
+ */
+async function promptSk(prompter, config) {
+    const existing = config?.sk ?? "";
+    return String(await prompter.text({
+        message: "XiaoYi Secret Key (sk)",
+        initialValue: existing,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    })).trim();
+}
+/**
+ * Prompt for Agent ID
+ */
+async function promptAgentId(prompter, config) {
+    const existing = config?.agentId ?? "";
+    return String(await prompter.text({
+        message: "XiaoYi Agent ID",
+        initialValue: existing,
+        validate: (value) => (value?.trim() ? undefined : "Required"),
+    })).trim();
+}
+exports.xiaoyiOnboardingAdapter = {
+    channel,
+    getStatus: async ({ cfg }) => {
+        const config = getXiaoYiConfig(cfg);
+        const configured = isXiaoYiConfigured(config);
+        const enabled = config?.enabled !== false;
+        const statusLines = [];
+        if (configured) {
+            statusLines.push(`XiaoYi: ${enabled ? "enabled" : "disabled"}`);
+            if (config?.wsUrl1 || config?.wsUrl) {
+                statusLines.push(`  WebSocket: ${config.wsUrl1 || config.wsUrl}`);
+            }
+            if (config?.wsUrl2) {
+                statusLines.push(`  Secondary: ${config.wsUrl2}`);
+            }
+            if (config?.agentId) {
+                statusLines.push(`  Agent ID: ${config.agentId}`);
+            }
+        }
+        else {
+            statusLines.push("XiaoYi: needs ak, sk, and agentId");
+        }
+        return {
+            channel,
+            configured,
+            statusLines,
+            selectionHint: configured ? "configured" : "needs setup",
+            quickstartScore: 50,
+        };
+    },
+    configure: async ({ cfg, prompter }) => {
+        const config = getXiaoYiConfig(cfg);
+        if (!isXiaoYiConfigured(config)) {
+            await noteXiaoYiSetupHelp(prompter);
+        }
+        else {
+            const reconfigure = await prompter.confirm({
+                message: "XiaoYi already configured. Reconfigure?",
+                initialValue: false,
+            });
+            if (!reconfigure) {
+                return { cfg, accountId: "default" };
+            }
+        }
+        // Prompt for required credentials
+        const ak = await promptAk(prompter, config);
+        const sk = await promptSk(prompter, config);
+        const agentId = await promptAgentId(prompter, config);
+        const cfgWithConfig = setXiaoYiConfig(cfg, {
+            ak,
+            sk,
+            agentId,
+            enabled: true,
+        });
+        return { cfg: cfgWithConfig, accountId: "default" };
+    },
+    disable: (cfg) => {
+        const xiaoyi = getXiaoYiConfig(cfg);
+        return {
+            ...cfg,
+            channels: {
+                ...cfg.channels,
+                xiaoyi: { ...xiaoyi, enabled: false },
+            },
+        };
+    },
+};

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

@@ -0,0 +1,191 @@
+import { XiaoYiWebSocketManager } from "./websocket.js";
+import { XiaoYiChannelConfig } from "./types.js";
+/**
+ * Timeout configuration
+ */
+export interface TimeoutConfig {
+    enabled: boolean;
+    duration: number;
+    message: string;
+}
+/**
+ * Runtime state for XiaoYi channel
+ * Manages single WebSocket connection (single account mode)
+ */
+export declare class XiaoYiRuntime {
+    private connection;
+    private pluginRuntime;
+    private config;
+    private sessionToTaskIdMap;
+    private instanceId;
+    private sessionTimeoutMap;
+    private sessionTimeoutSent;
+    private timeoutConfig;
+    private sessionAbortControllerMap;
+    private sessionActiveRunMap;
+    private sessionStartTimeMap;
+    private static readonly SESSION_STALE_TIMEOUT_MS;
+    private sessionTaskTimeoutMap;
+    private sessionPushPendingMap;
+    private taskTimeoutMs;
+    constructor();
+    getInstanceId(): string;
+    /**
+     * Set OpenClaw PluginRuntime (from api.runtime in register())
+     */
+    setPluginRuntime(runtime: any): void;
+    /**
+     * Get OpenClaw PluginRuntime
+     */
+    getPluginRuntime(): any;
+    /**
+     * Start connection (single account mode)
+     */
+    start(config: XiaoYiChannelConfig): Promise<void>;
+    /**
+     * Stop connection
+     */
+    stop(): void;
+    /**
+     * Set timeout configuration
+     */
+    setTimeoutConfig(config: Partial<TimeoutConfig>): void;
+    /**
+     * Get timeout configuration
+     */
+    getTimeoutConfig(): TimeoutConfig;
+    /**
+     * Set timeout for a session
+     * @param sessionId - Session ID
+     * @param callback - Function to call when timeout occurs
+     * @returns The interval ID (for cancellation)
+     *
+     * IMPORTANT: This now uses setInterval instead of setTimeout
+     * - First trigger: after 60 seconds
+     * - Subsequent triggers: every 60 seconds after that
+     * - Cleared when: response received, session completed, or explicitly cleared
+     */
+    setTimeoutForSession(sessionId: string, callback: () => void): NodeJS.Timeout | undefined;
+    /**
+     * Clear timeout interval for a session
+     * @param sessionId - Session ID
+     */
+    clearSessionTimeout(sessionId: string): void;
+    /**
+     * Check if timeout has been sent for a session
+     * @param sessionId - Session ID
+     */
+    isSessionTimeout(sessionId: string): boolean;
+    /**
+     * Mark session as completed (clear timeout and timeout flag)
+     * @param sessionId - Session ID
+     */
+    markSessionCompleted(sessionId: string): void;
+    /**
+     * Clear all timeout intervals
+     */
+    clearAllTimeouts(): void;
+    /**
+     * Get WebSocket manager
+     */
+    getConnection(): XiaoYiWebSocketManager | null;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get configuration
+     */
+    getConfig(): XiaoYiChannelConfig | null;
+    /**
+     * Set taskId for a session
+     */
+    setTaskIdForSession(sessionId: string, taskId: string): void;
+    /**
+     * Get taskId for a session
+     */
+    getTaskIdForSession(sessionId: string): string | undefined;
+    /**
+     * Clear taskId for a session
+     */
+    clearTaskIdForSession(sessionId: string): void;
+    /**
+     * Create and register an AbortController for a session
+     * @param sessionId - Session ID
+     * @returns The AbortController and its signal, or null if session is busy
+     */
+    createAbortControllerForSession(sessionId: string): {
+        controller: AbortController;
+        signal: AbortSignal;
+    } | 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
+     */
+    isSessionActive(sessionId: string): boolean;
+    /**
+     * Abort a session's agent run
+     * @param sessionId - Session ID
+     * @returns true if a controller was found and aborted, false otherwise
+     */
+    abortSession(sessionId: string): boolean;
+    /**
+     * Check if a session has been aborted
+     * @param sessionId - Session ID
+     * @returns true if the session's abort signal was triggered
+     */
+    isSessionAborted(sessionId: string): boolean;
+    /**
+     * Clear the AbortController for a session (call when agent completes successfully)
+     * @param sessionId - Session ID
+     */
+    clearAbortControllerForSession(sessionId: string): void;
+    /**
+     * 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;