@ynhcj/xiaoyi-channel 0.0.1

package/dist/src/monitor.js

@@ -0,0 +1,119 @@
+import { resolveXYConfig } from "./config.js";
+import { getXYWebSocketManager } from "./client.js";
+import { getXYRuntime } from "./runtime.js";
+import { handleXYMessage } from "./bot.js";
+/**
+ * Per-session serial queue that ensures messages from the same session are processed
+ * in arrival order while allowing different sessions to run concurrently.
+ * Following feishu/monitor.account.ts pattern.
+ */
+function createSessionQueue() {
+    const queues = new Map();
+    return (sessionId, task) => {
+        const prev = queues.get(sessionId) ?? Promise.resolve();
+        const next = prev.then(task, task);
+        queues.set(sessionId, next);
+        void next.finally(() => {
+            if (queues.get(sessionId) === next) {
+                queues.delete(sessionId);
+            }
+        });
+        return next;
+    };
+}
+/**
+ * Monitor XY channel WebSocket connections.
+ * Keeps the connection alive until abortSignal is triggered.
+ */
+export async function monitorXYProvider(opts = {}) {
+    const cfg = opts.config;
+    if (!cfg) {
+        throw new Error("Config is required for XY monitor");
+    }
+    // Validate runtime early - fail fast if plugin not registered
+    // Following feishu/monitor.account.ts pattern
+    const core = getXYRuntime();
+    const runtime = opts.runtime;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    const account = resolveXYConfig(cfg);
+    if (!account.enabled) {
+        throw new Error(`XY account is disabled`);
+    }
+    const accountId = opts.accountId ?? "default";
+    // Get WebSocket manager (cached)
+    const wsManager = getXYWebSocketManager(account);
+    // Track logged servers to avoid duplicate logs
+    const loggedServers = new Set();
+    // Create session queue for ordered message processing
+    const enqueue = createSessionQueue();
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            log("XY gateway: cleaning up...");
+            wsManager.disconnect();
+            loggedServers.clear();
+        };
+        const handleAbort = () => {
+            log("XY gateway: abort signal received, stopping");
+            cleanup();
+            log("XY gateway stopped");
+            resolve();
+        };
+        if (opts.abortSignal?.aborted) {
+            cleanup();
+            resolve();
+            return;
+        }
+        opts.abortSignal?.addEventListener("abort", handleAbort, { once: true });
+        // Setup event handlers
+        const messageHandler = (message, sessionId, serverId) => {
+            const task = async () => {
+                try {
+                    await handleXYMessage({
+                        cfg,
+                        runtime,
+                        message,
+                        accountId, // ✅ Pass accountId ("default")
+                    });
+                }
+                catch (err) {
+                    error(`XY gateway: error handling message from ${serverId}: ${String(err)}`);
+                    throw err;
+                }
+            };
+            void enqueue(sessionId, task).catch((err) => {
+                // Error already logged in task, this is for queue failures
+                error(`XY gateway: queue processing failed for session ${sessionId}: ${String(err)}`);
+            });
+        };
+        const connectedHandler = (serverId) => {
+            if (!loggedServers.has(serverId)) {
+                log(`XY gateway: ${serverId} connected`);
+                loggedServers.add(serverId);
+            }
+        };
+        const disconnectedHandler = (serverId) => {
+            console.warn(`XY gateway: ${serverId} disconnected`);
+            loggedServers.delete(serverId);
+        };
+        const errorHandler = (err, serverId) => {
+            error(`XY gateway: ${serverId} error: ${String(err)}`);
+        };
+        // Register event handlers
+        wsManager.on("message", messageHandler);
+        wsManager.on("connected", connectedHandler);
+        wsManager.on("disconnected", disconnectedHandler);
+        wsManager.on("error", errorHandler);
+        // Connect to WebSocket servers
+        wsManager.connect()
+            .then(() => {
+            log("XY gateway: started successfully");
+        })
+            .catch((err) => {
+            // Connection failed but don't reject - continue monitoring for reconnection
+            error(`XY gateway: initial connection failed: ${String(err)}`);
+            // Still resolve successfully so plugin starts
+            resolve();
+        });
+    });
+}

package/dist/src/onboarding.d.ts

@@ -0,0 +1,6 @@
+import type { ChannelOnboardingAdapter } from "openclaw/plugin-sdk";
+/**
+ * XY Channel Onboarding Adapter
+ * Implements the ChannelOnboardingAdapter interface for OpenClaw's onboarding system
+ */
+export declare const xyOnboardingAdapter: ChannelOnboardingAdapter;

package/dist/src/onboarding.js

@@ -0,0 +1,173 @@
+const channel = "xy";
+/**
+ * Check if XY channel is properly configured with required fields
+ */
+function isXYConfigured(cfg) {
+    try {
+        const xyConfig = cfg.channels?.xy;
+        if (!xyConfig) {
+            return false;
+        }
+        // Check required fields
+        const requiredFields = ["apiKey", "agentId", "uid", "apiId", "pushId"];
+        for (const field of requiredFields) {
+            if (!xyConfig[field] || (typeof xyConfig[field] === "string" && !xyConfig[field].trim())) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get current status of XY channel configuration
+ */
+async function getStatus({ cfg }) {
+    const configured = isXYConfigured(cfg);
+    const xyConfig = cfg.channels?.xy;
+    const statusLines = [];
+    if (configured) {
+        const wsUrl1 = xyConfig?.wsUrl1 || "ws://localhost:8765/ws/link";
+        const wsUrl2 = xyConfig?.wsUrl2 || "ws://localhost:8768/ws/link";
+        statusLines.push(`XY: configured (双 WebSocket: ${wsUrl1}, ${wsUrl2})`);
+    }
+    else {
+        statusLines.push("XY: 需要配置 (需要 apiKey, agentId, uid, apiId, pushId)");
+    }
+    return {
+        channel,
+        configured,
+        statusLines,
+        selectionHint: configured ? "configured" : "需要配置",
+        quickstartScore: configured ? 5 : 0,
+    };
+}
+/**
+ * Configure XY channel through interactive prompts
+ */
+async function configure({ cfg, prompter, }) {
+    // Note current configuration status
+    const currentConfig = cfg.channels?.xy;
+    const isUpdate = Boolean(currentConfig);
+    await prompter.note([
+        "XY Channel - 小艺 A2A 协议配置",
+        "",
+        "XY 是小艺智能助手的 A2A (Agent-to-Agent) 协议集成，",
+        "需要配置双 WebSocket 连接和相关认证信息。",
+        "",
+        isUpdate ? "当前配置将被更新。" : "首次配置 XY channel。",
+    ].join("\n"), "XY Channel 配置");
+    // Prompt for WebSocket URLs
+    const wsUrl1 = await prompter.text({
+        message: "WebSocket URL 1 (主连接)",
+        initialValue: currentConfig?.wsUrl1 || "ws://localhost:8765/ws/link",
+        placeholder: "ws://localhost:8765/ws/link",
+    });
+    const wsUrl2 = await prompter.text({
+        message: "WebSocket URL 2 (辅助连接)",
+        initialValue: currentConfig?.wsUrl2 || "ws://localhost:8768/ws/link",
+        placeholder: "ws://localhost:8768/ws/link",
+    });
+    // Prompt for required authentication fields
+    const apiKey = await prompter.text({
+        message: "API Key (必需)",
+        initialValue: currentConfig?.apiKey || "",
+        placeholder: "输入小艺 API Key",
+        validate: (value) => (value.trim() ? undefined : "API Key 不能为空"),
+    });
+    const uid = await prompter.text({
+        message: "UID - 用户ID (必需)",
+        initialValue: currentConfig?.uid || "",
+        placeholder: "输入用户 ID",
+        validate: (value) => (value.trim() ? undefined : "UID 不能为空"),
+    });
+    const agentId = await prompter.text({
+        message: "Agent ID - 智能体ID (必需)",
+        initialValue: currentConfig?.agentId || "",
+        placeholder: "agent5336cca603f941ee9b112f711805e866",
+        validate: (value) => (value.trim() ? undefined : "Agent ID 不能为空"),
+    });
+    const apiId = await prompter.text({
+        message: "API ID (必需)",
+        initialValue: currentConfig?.apiId || "",
+        placeholder: "输入 API ID",
+        validate: (value) => (value.trim() ? undefined : "API ID 不能为空"),
+    });
+    const pushId = await prompter.text({
+        message: "Push ID (必需)",
+        initialValue: currentConfig?.pushId || "",
+        placeholder: "输入 Push ID",
+        validate: (value) => (value.trim() ? undefined : "Push ID 不能为空"),
+    });
+    // Optional fields
+    const fileUploadUrl = await prompter.text({
+        message: "File Upload URL (文件上传服务)",
+        initialValue: currentConfig?.fileUploadUrl || "http://localhost:8767",
+        placeholder: "http://localhost:8767",
+    });
+    const pushUrl = await prompter.text({
+        message: "Push URL (推送服务，可选)",
+        initialValue: currentConfig?.pushUrl || "",
+        placeholder: "留空使用默认值",
+    });
+    // Update configuration
+    const updatedConfig = {
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            xy: {
+                enabled: true,
+                wsUrl1: wsUrl1.trim(),
+                wsUrl2: wsUrl2.trim(),
+                apiKey: apiKey.trim(),
+                uid: uid.trim(),
+                agentId: agentId.trim(),
+                apiId: apiId.trim(),
+                pushId: pushId.trim(),
+                fileUploadUrl: fileUploadUrl.trim(),
+                ...(pushUrl?.trim() ? { pushUrl: pushUrl.trim() } : {}),
+            },
+        },
+    };
+    // Show confirmation
+    await prompter.note([
+        "✅ XY Channel 配置完成",
+        "",
+        `主连接: ${wsUrl1}`,
+        `辅助连接: ${wsUrl2}`,
+        `Agent ID: ${agentId}`,
+        `UID: ${uid}`,
+        "",
+        "运行以下命令启动 gateway:",
+        "  openclaw gateway restart",
+        "",
+        "查看日志:",
+        "  openclaw logs --follow",
+    ].join("\n"), "配置成功");
+    return {
+        cfg: updatedConfig,
+        accountId: "default",
+    };
+}
+/**
+ * XY Channel Onboarding Adapter
+ * Implements the ChannelOnboardingAdapter interface for OpenClaw's onboarding system
+ */
+export const xyOnboardingAdapter = {
+    channel,
+    getStatus,
+    configure,
+    // Optional: disable the channel
+    disable: (cfg) => ({
+        ...cfg,
+        channels: {
+            ...cfg.channels,
+            xy: {
+                ...(cfg.channels?.xy || {}),
+                enabled: false,
+            },
+        },
+    }),
+};

package/dist/src/outbound.d.ts

@@ -0,0 +1,6 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+/**
+ * Outbound adapter for sending messages from OpenClaw to XY.
+ * Uses Push service for direct message delivery.
+ */
+export declare const xyOutbound: ChannelOutboundAdapter;

package/dist/src/outbound.js

@@ -0,0 +1,143 @@
+import { resolveXYConfig } from "./config.js";
+import { XYFileUploadService } from "./file-upload.js";
+import { XYPushService } from "./push.js";
+// Special marker for default push delivery when no target is specified
+const DEFAULT_PUSH_MARKER = "default";
+/**
+ * Outbound adapter for sending messages from OpenClaw to XY.
+ * Uses Push service for direct message delivery.
+ */
+export const xyOutbound = {
+    deliveryMode: "direct",
+    textChunkLimit: 4000,
+    /**
+     * Resolve delivery target for XY channel.
+     * When no target is specified (e.g., in cron jobs with announce mode),
+     * returns a default marker that will be handled by sendText.
+     */
+    resolveTarget: ({ cfg, to, accountId, mode }) => {
+        // If no target provided, use default marker for push delivery
+        if (!to || to.trim() === "") {
+            console.log(`[xyOutbound.resolveTarget] No target specified, using default push marker`);
+            return {
+                ok: true,
+                to: DEFAULT_PUSH_MARKER,
+            };
+        }
+        // Otherwise, use the provided target
+        console.log(`[xyOutbound.resolveTarget] Using provided target:`, to);
+        return {
+            ok: true,
+            to: to.trim(),
+        };
+    },
+    sendText: async ({ cfg, to, text, accountId }) => {
+        // Log parameters
+        console.log(`[xyOutbound.sendText] Called with:`, {
+            to,
+            accountId,
+            textLength: text?.length || 0,
+            textPreview: text?.slice(0, 100),
+        });
+        // Resolve configuration
+        const config = resolveXYConfig(cfg);
+        // Handle default push marker (for cron jobs without explicit target)
+        let actualTo = to;
+        if (to === DEFAULT_PUSH_MARKER) {
+            console.log(`[xyOutbound.sendText] Using default push delivery (no specific target)`);
+            // For push notifications, we don't need a specific target
+            // The push service will handle it based on config
+            actualTo = config.defaultSessionId || "";
+        }
+        // Create push service
+        const pushService = new XYPushService(config);
+        // Extract title (first 57 chars or first line)
+        const title = text.split("\n")[0].slice(0, 57);
+        // Send push message
+        await pushService.sendPush(text, title, actualTo);
+        console.log(`[xyOutbound.sendText] Completed successfully`);
+        // Return message info
+        return {
+            channel: "xy",
+            messageId: Date.now().toString(),
+            chatId: actualTo,
+        };
+    },
+    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
+        // Log parameters
+        console.log(`[xyOutbound.sendMedia] Called with:`, {
+            to,
+            accountId,
+            text,
+            mediaUrl,
+            mediaLocalRoots,
+        });
+        // Parse to: "sessionId::taskId"
+        const parts = to.split("::");
+        if (parts.length !== 2) {
+            throw new Error(`Invalid to format: "${to}". Expected "sessionId::taskId"`);
+        }
+        const [sessionId, taskId] = parts;
+        // Resolve configuration
+        const config = resolveXYConfig(cfg);
+        // Create upload service
+        const uploadService = new XYFileUploadService(config.fileUploadUrl, config.apiKey, config.uid);
+        // Validate mediaUrl
+        if (!mediaUrl) {
+            throw new Error("mediaUrl is required for sendMedia");
+        }
+        // Upload file
+        const fileId = await uploadService.uploadFile(mediaUrl);
+        console.log(`[xyOutbound.sendMedia] File uploaded:`, {
+            fileId,
+            sessionId,
+            taskId,
+        });
+        // Get filename and mime type from mediaUrl
+        // mediaUrl may be a local file path or URL
+        const fileName = mediaUrl.split("/").pop() || "unknown";
+        const mimeType = text?.match(/\[ MediaType: ([^\]]+)\]/)?.[1] || "application/octet-stream";
+        // Build agent_response message
+        const agentResponse = {
+            msgType: "agent_response",
+            agentId: config.agentId,
+            sessionId: sessionId,
+            taskId: taskId,
+            msgDetail: JSON.stringify({
+                jsonrpc: "2.0",
+                id: taskId,
+                result: {
+                    kind: "artifact-update",
+                    append: true,
+                    lastChunk: false,
+                    final: false,
+                    artifact: {
+                        artifactId: taskId,
+                        parts: [
+                            {
+                                kind: "file",
+                                file: {
+                                    name: fileName,
+                                    mimeType: mimeType,
+                                    fileId: fileId,
+                                },
+                            },
+                        ],
+                    },
+                },
+                error: { code: 0 },
+            }),
+        };
+        // Get WebSocket manager and send message
+        const { getXYWebSocketManager } = await import("./client.js");
+        const wsManager = getXYWebSocketManager(config);
+        await wsManager.sendMessage(sessionId, agentResponse);
+        console.log(`[xyOutbound.sendMedia] WebSocket message sent successfully`);
+        // Return message info
+        return {
+            channel: "xy",
+            messageId: fileId,
+            chatId: to,
+        };
+    },
+};

package/dist/src/parser.d.ts

@@ -0,0 +1,44 @@
+import type { A2AJsonRpcRequest, A2AMessagePart, A2ADataEvent } from "./types.js";
+/**
+ * Parsed message information extracted from A2A request.
+ * Note: agentId is not extracted from message - it should come from config.
+ */
+export interface ParsedA2AMessage {
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    parts: A2AMessagePart[];
+    method: string;
+}
+/**
+ * Parse an A2A JSON-RPC request into structured message data.
+ */
+export declare function parseA2AMessage(request: A2AJsonRpcRequest): ParsedA2AMessage;
+/**
+ * Extract text content from message parts.
+ */
+export declare function extractTextFromParts(parts: A2AMessagePart[]): string;
+/**
+ * Extract file parts from message parts.
+ */
+export declare function extractFileParts(parts: A2AMessagePart[]): Array<{
+    name: string;
+    mimeType: string;
+    uri: string;
+}>;
+/**
+ * Extract data events from message parts (for tool responses).
+ */
+export declare function extractDataEvents(parts: A2AMessagePart[]): A2ADataEvent[];
+/**
+ * Check if message is a clearContext request.
+ */
+export declare function isClearContextMessage(method: string): boolean;
+/**
+ * Check if message is a tasks/cancel request.
+ */
+export declare function isTasksCancelMessage(method: string): boolean;
+/**
+ * Validate A2A request structure.
+ */
+export declare function validateA2ARequest(request: any): request is A2AJsonRpcRequest;

package/dist/src/parser.js

@@ -0,0 +1,84 @@
+import { logger } from "./utils/logger.js";
+/**
+ * Parse an A2A JSON-RPC request into structured message data.
+ */
+export function parseA2AMessage(request) {
+    const { method, params, id } = request;
+    if (!params) {
+        throw new Error("A2A request missing params");
+    }
+    const { sessionId, message, id: paramsId } = params;
+    if (!sessionId || !message) {
+        throw new Error("A2A request params missing required fields");
+    }
+    return {
+        sessionId,
+        taskId: paramsId, // Task ID from params (对话唯一标识)
+        messageId: id, // Global unique message sequence ID from top-level request
+        parts: message.parts || [],
+        method,
+    };
+}
+/**
+ * Extract text content from message parts.
+ */
+export function extractTextFromParts(parts) {
+    const textParts = parts
+        .filter((part) => part.kind === "text")
+        .map((part) => part.text);
+    return textParts.join("\n").trim();
+}
+/**
+ * Extract file parts from message parts.
+ */
+export function extractFileParts(parts) {
+    return parts
+        .filter((part) => part.kind === "file")
+        .map((part) => part.file);
+}
+/**
+ * Extract data events from message parts (for tool responses).
+ */
+export function extractDataEvents(parts) {
+    return parts
+        .filter((part) => part.kind === "data")
+        .map((part) => part.data.event)
+        .filter((event) => event !== undefined);
+}
+/**
+ * Check if message is a clearContext request.
+ */
+export function isClearContextMessage(method) {
+    return method === "clearContext" || method === "clear_context";
+}
+/**
+ * Check if message is a tasks/cancel request.
+ */
+export function isTasksCancelMessage(method) {
+    return method === "tasks/cancel" || method === "tasks_cancel";
+}
+/**
+ * Validate A2A request structure.
+ */
+export function validateA2ARequest(request) {
+    if (!request || typeof request !== "object") {
+        return false;
+    }
+    if (request.jsonrpc !== "2.0") {
+        logger.warn("Invalid JSON-RPC version:", request.jsonrpc);
+        return false;
+    }
+    if (!request.method || typeof request.method !== "string") {
+        logger.warn("Missing or invalid method");
+        return false;
+    }
+    if (!request.id) {
+        logger.warn("Missing request id");
+        return false;
+    }
+    if (!request.params || typeof request.params !== "object") {
+        logger.warn("Missing or invalid params");
+        return false;
+    }
+    return true;
+}

package/dist/src/push.d.ts

@@ -0,0 +1,17 @@
+import type { XYChannelConfig } from "./types.js";
+/**
+ * Service for sending push messages to users.
+ * Used for outbound messages and scheduled tasks.
+ */
+export declare class XYPushService {
+    private config;
+    constructor(config: XYChannelConfig);
+    /**
+     * Send a push message to a user session.
+     */
+    sendPush(content: string, title: string, sessionId?: string): Promise<void>;
+    /**
+     * Send a push message with file attachments.
+     */
+    sendPushWithFiles(content: string, title: string, fileIds: string[], sessionId?: string): Promise<void>;
+}

package/dist/src/push.js

@@ -0,0 +1,55 @@
+// Push message service for scheduled tasks
+import fetch from "node-fetch";
+import { logger } from "./utils/logger.js";
+/**
+ * Service for sending push messages to users.
+ * Used for outbound messages and scheduled tasks.
+ */
+export class XYPushService {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Send a push message to a user session.
+     */
+    async sendPush(content, title, sessionId) {
+        const pushUrl = this.config.pushUrl || `${this.config.fileUploadUrl}/push`;
+        logger.debug(`Sending push message: title="${title}"`);
+        try {
+            const request = {
+                apiKey: this.config.apiKey,
+                apiId: this.config.apiId,
+                pushId: this.config.pushId,
+                sessionId: sessionId || "default",
+                title,
+                content,
+            };
+            const response = await fetch(pushUrl, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": this.config.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok) {
+                throw new Error(`Push failed: HTTP ${response.status}`);
+            }
+            logger.log(`Push message sent successfully: "${title}"`);
+        }
+        catch (error) {
+            logger.error("Failed to send push message:", error);
+            throw error;
+        }
+    }
+    /**
+     * Send a push message with file attachments.
+     */
+    async sendPushWithFiles(content, title, fileIds, sessionId) {
+        // Build content with file references
+        const contentWithFiles = `${content}\n\n[文件: ${fileIds.join(", ")}]`;
+        await this.sendPush(contentWithFiles, title, sessionId);
+    }
+}

package/dist/src/reply-dispatcher.d.ts

@@ -0,0 +1,15 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+export interface CreateXYReplyDispatcherParams {
+    cfg: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    accountId: string;
+}
+/**
+ * Create a reply dispatcher for XY channel messages.
+ * Follows feishu pattern with status updates and streaming support.
+ * Runtime is expected to be validated before calling this function.
+ */
+export declare function createXYReplyDispatcher(params: CreateXYReplyDispatcherParams): any;