@ynhcj/xiaoyi-channel 0.0.1-beta

package/dist/src/config-schema.js

@@ -0,0 +1,55 @@
+// JSON Schema definition for XY channel configuration
+export const xyConfigSchema = {
+    type: "object",
+    properties: {
+        enabled: {
+            type: "boolean",
+            description: "Enable/disable the XY channel",
+            default: false,
+        },
+        wsUrl1: {
+            type: "string",
+            description: "Primary WebSocket URL",
+            default: "ws://localhost:8765/ws/link",
+        },
+        wsUrl2: {
+            type: "string",
+            description: "Secondary WebSocket URL",
+            default: "ws://localhost:8768/ws/link",
+        },
+        apiKey: {
+            type: "string",
+            description: "API key for authentication",
+        },
+        uid: {
+            type: "string",
+            description: "User ID for file upload",
+        },
+        agentId: {
+            type: "string",
+            description: "Agent ID for this bot instance",
+        },
+        apiId: {
+            type: "string",
+            description: "API ID for push messages",
+        },
+        pushId: {
+            type: "string",
+            description: "Push ID for push messages",
+        },
+        fileUploadUrl: {
+            type: "string",
+            description: "Base URL for file upload service",
+            default: "http://localhost:8767",
+        },
+        pushUrl: {
+            type: "string",
+            description: "URL for push message service",
+        },
+        defaultSessionId: {
+            type: "string",
+            description: "Default session ID for push notifications (used when no target is specified, e.g., in cron jobs)",
+        },
+    },
+    required: ["apiKey", "agentId", "uid", "apiId", "pushId"],
+};

package/dist/src/config.d.ts

@@ -0,0 +1,17 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { XYChannelConfig } from "./types.js";
+/**
+ * Resolve and validate Xiaoyi channel configuration from ClawdbotConfig.
+ * Simplified version - only supports single account (no multi-account management).
+ */
+export declare function resolveXYConfig(cfg: ClawdbotConfig): XYChannelConfig;
+/**
+ * List available account IDs.
+ * Simplified - always returns single account "default".
+ */
+export declare function listXYAccountIds(): string[];
+/**
+ * Get default account ID.
+ * Simplified - always returns "default".
+ */
+export declare function getDefaultXYAccountId(): string;

package/dist/src/config.js

@@ -0,0 +1,45 @@
+/**
+ * Resolve and validate Xiaoyi channel configuration from ClawdbotConfig.
+ * Simplified version - only supports single account (no multi-account management).
+ */
+export function resolveXYConfig(cfg) {
+    const xyConfig = cfg.channels?.["xiaoyi-channel"];
+    if (!xyConfig) {
+        throw new Error("Xiaoyi channel configuration not found in openclaw.json");
+    }
+    // Validate required fields
+    const required = ["apiKey", "agentId", "uid", "apiId", "pushId"];
+    for (const field of required) {
+        if (!xyConfig[field]) {
+            throw new Error(`XY channel configuration missing required field: ${field}`);
+        }
+    }
+    // Return configuration with defaults
+    return {
+        enabled: xyConfig.enabled ?? false,
+        wsUrl1: xyConfig.wsUrl1 ?? "ws://localhost:8765/ws/link",
+        wsUrl2: xyConfig.wsUrl2 ?? "ws://localhost:8768/ws/link",
+        apiKey: xyConfig.apiKey,
+        uid: xyConfig.uid,
+        agentId: xyConfig.agentId,
+        apiId: xyConfig.apiId,
+        pushId: xyConfig.pushId,
+        fileUploadUrl: xyConfig.fileUploadUrl ?? "http://localhost:8767",
+        pushUrl: xyConfig.pushUrl,
+        defaultSessionId: xyConfig.defaultSessionId,
+    };
+}
+/**
+ * List available account IDs.
+ * Simplified - always returns single account "default".
+ */
+export function listXYAccountIds() {
+    return ["default"];
+}
+/**
+ * Get default account ID.
+ * Simplified - always returns "default".
+ */
+export function getDefaultXYAccountId() {
+    return "default";
+}

package/dist/src/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/src/file-download.js

@@ -0,0 +1,53 @@
+// File download utilities
+import fetch from "node-fetch";
+import fs from "fs/promises";
+import path from "path";
+import { logger } from "./utils/logger.js";
+/**
+ * Download a file from URL to local path.
+ */
+export async function downloadFile(url, destPath) {
+    logger.debug(`Downloading file from ${url} to ${destPath}`);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        await fs.writeFile(destPath, buffer);
+        logger.debug(`File downloaded successfully: ${destPath}`);
+    }
+    catch (error) {
+        logger.error(`Failed to download file from ${url}:`, error);
+        throw error;
+    }
+}
+/**
+ * Download files from A2A file parts.
+ * Returns array of local file paths.
+ */
+export async function downloadFilesFromParts(fileParts, tempDir = "/tmp/xy_channel") {
+    // Create temp directory if it doesn't exist
+    await fs.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.join(tempDir, `${Date.now()}_${safeName}`);
+        try {
+            await downloadFile(uri, destPath);
+            downloadedFiles.push({
+                path: destPath,
+                name,
+                mimeType,
+            });
+        }
+        catch (error) {
+            logger.error(`Failed to download file ${name}:`, error);
+            // Continue with other files
+        }
+    }
+    return downloadedFiles;
+}

package/dist/src/file-upload.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Service for uploading files to XY file storage.
+ * Implements three-phase upload: prepare → upload → complete.
+ */
+export declare class XYFileUploadService {
+    private baseUrl;
+    private apiKey;
+    private uid;
+    constructor(baseUrl: string, apiKey: string, uid: string);
+    /**
+     * Upload a file using the three-phase process.
+     * Returns the objectId (as fileId) for use in A2A messages.
+     */
+    uploadFile(filePath: string, objectType?: string): Promise<string>;
+    /**
+     * Upload multiple files and return their file IDs.
+     */
+    uploadFiles(filePaths: string[], objectType?: string): Promise<Array<{
+        filePath: string;
+        fileId: string;
+        fileName: string;
+    }>>;
+}

package/dist/src/file-upload.js

@@ -0,0 +1,129 @@
+// Three-phase file upload service
+// OSMS file upload implementation
+import fetch from "node-fetch";
+import fs from "fs/promises";
+import path from "path";
+import { calculateSHA256 } from "./utils/crypto.js";
+/**
+ * Service for uploading files to XY file storage.
+ * Implements three-phase upload: prepare → upload → complete.
+ */
+export class XYFileUploadService {
+    baseUrl;
+    apiKey;
+    uid;
+    constructor(baseUrl, apiKey, uid) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.uid = uid;
+    }
+    /**
+     * Upload a file using the three-phase process.
+     * Returns the objectId (as fileId) for use in A2A messages.
+     */
+    async uploadFile(filePath, objectType = "TEMPORARY_MATERIAL_DOC") {
+        console.log(`[XY File Upload] Starting file upload: ${filePath}`);
+        try {
+            // Read file
+            const fileBuffer = await fs.readFile(filePath);
+            const fileName = path.basename(filePath);
+            const fileSha256 = calculateSHA256(fileBuffer);
+            const fileSize = fileBuffer.length;
+            // Phase 1: Prepare
+            console.log(`[XY File Upload] Phase 1: Prepare upload for ${fileName}`);
+            const prepareResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/prepare`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectType,
+                    fileName,
+                    fileSha256,
+                    fileSize,
+                    fileOwnerInfo: {
+                        uid: this.uid,
+                        teamId: this.uid,
+                    },
+                    useEdge: false,
+                }),
+            });
+            if (!prepareResp.ok) {
+                throw new Error(`Prepare failed: HTTP ${prepareResp.status}`);
+            }
+            const prepareData = await prepareResp.json();
+            console.log(`[XY File Upload] Prepare response:`, JSON.stringify(prepareData, null, 2));
+            if (prepareData.code !== "0") {
+                throw new Error(`Prepare failed: ${prepareData.desc}`);
+            }
+            const { objectId, draftId, uploadInfos } = prepareData;
+            console.log(`[XY File Upload] Prepare complete: objectId=${objectId}, draftId=${draftId}`);
+            // Phase 2: Upload
+            console.log(`[XY File Upload] Phase 2: Upload file data`);
+            const uploadInfo = uploadInfos[0]; // Single-part upload
+            const uploadResp = await fetch(uploadInfo.url, {
+                method: uploadInfo.method,
+                headers: uploadInfo.headers,
+                body: fileBuffer,
+            });
+            console.log(`[XY File Upload] Upload response status: ${uploadResp.status}, url: ${uploadInfo.url}`);
+            console.log(`[XY File Upload] Upload response headers:`, JSON.stringify(Object.fromEntries(uploadResp.headers.entries()), null, 2));
+            if (!uploadResp.ok) {
+                const uploadErrorText = await uploadResp.text();
+                console.log(`[XY File Upload] Upload error response:`, uploadErrorText);
+                throw new Error(`Upload failed: HTTP ${uploadResp.status}`);
+            }
+            console.log(`[XY File Upload] Upload complete`);
+            // Phase 3: Complete
+            console.log(`[XY File Upload] Phase 3: Complete upload`);
+            const completeResp = await fetch(`${this.baseUrl}/osms/v1/file/manager/complete`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-uid": this.uid,
+                    "x-api-key": this.apiKey,
+                    "x-request-from": "openclaw",
+                },
+                body: JSON.stringify({
+                    objectId,
+                    draftId,
+                }),
+            });
+            if (!completeResp.ok) {
+                throw new Error(`Complete failed: HTTP ${completeResp.status}`);
+            }
+            const completeData = await completeResp.json();
+            console.log(`[XY File Upload] Complete response:`, JSON.stringify(completeData, null, 2));
+            console.log(`[XY File Upload] File upload successful: ${fileName} → objectId=${objectId}`);
+            return objectId;
+        }
+        catch (error) {
+            console.error(`[XY File Upload] File upload failed for ${filePath}:`, error);
+            return "";
+        }
+    }
+    /**
+     * Upload multiple files and return their file IDs.
+     */
+    async uploadFiles(filePaths, objectType = "TEMPORARY_MATERIAL_DOC") {
+        const results = [];
+        for (const filePath of filePaths) {
+            try {
+                const fileId = await this.uploadFile(filePath, objectType);
+                results.push({
+                    filePath,
+                    fileId,
+                    fileName: path.basename(filePath),
+                });
+            }
+            catch (error) {
+                console.error(`[XY File Upload] Failed to upload ${filePath}, skipping:`, error);
+                // Continue with other files
+            }
+        }
+        return results;
+    }
+}

package/dist/src/formatter.d.ts

@@ -0,0 +1,77 @@
+import type { XYChannelConfig, A2ACommand } from "./types.js";
+/**
+ * Parameters for sending an A2A response.
+ */
+export interface SendA2AResponseParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text?: string;
+    append: boolean;
+    final: boolean;
+    files?: Array<{
+        fileName: string;
+        fileType: string;
+        fileId: string;
+    }>;
+}
+/**
+ * Send an A2A artifact update response.
+ */
+export declare function sendA2AResponse(params: SendA2AResponseParams): Promise<void>;
+/**
+ * Parameters for sending a status update.
+ */
+export interface SendStatusUpdateParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    text: string;
+    state: "submitted" | "working" | "input-required" | "completed" | "canceled" | "failed" | "unknown";
+}
+/**
+ * Send an A2A task status update.
+ * Follows A2A protocol standard format with nested status object.
+ */
+export declare function sendStatusUpdate(params: SendStatusUpdateParams): Promise<void>;
+/**
+ * Parameters for sending a command.
+ */
+export interface SendCommandParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    command: A2ACommand;
+}
+/**
+ * Send a command as an artifact update (final=false).
+ */
+export declare function sendCommand(params: SendCommandParams): Promise<void>;
+/**
+ * Parameters for sending a clearContext response.
+ */
+export interface SendClearContextResponseParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    messageId: string;
+}
+/**
+ * Send a clearContext response.
+ */
+export declare function sendClearContextResponse(params: SendClearContextResponseParams): Promise<void>;
+/**
+ * Parameters for sending a tasks/cancel response.
+ */
+export interface SendTasksCancelResponseParams {
+    config: XYChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+}
+/**
+ * Send a tasks/cancel response.
+ */
+export declare function sendTasksCancelResponse(params: SendTasksCancelResponseParams): Promise<void>;

package/dist/src/formatter.js

@@ -0,0 +1,252 @@
+// OpenClaw → A2A format conversion
+import { v4 as uuidv4 } from "uuid";
+import { getXYWebSocketManager } from "./client.js";
+import { getXYRuntime } from "./runtime.js";
+/**
+ * Send an A2A artifact update response.
+ */
+export async function sendA2AResponse(params) {
+    const { config, sessionId, taskId, messageId, text, append, final, files } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build artifact update event
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append,
+        lastChunk: true,
+        final,
+        artifact: {
+            artifactId: uuidv4(),
+            parts: [],
+        },
+    };
+    // Add text part (even if empty string, to maintain parts structure)
+    if (text !== undefined) {
+        artifact.artifact.parts.push({
+            kind: "text",
+            text,
+        });
+    }
+    // Add file parts if provided
+    if (files && files.length > 0) {
+        artifact.artifact.parts.push({
+            kind: "data",
+            data: { fileInfo: files },
+        });
+    }
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_RESPONSE] 📤 Sending A2A artifact-update response:`);
+    log(`[A2A_RESPONSE]   - sessionId: ${sessionId}`);
+    log(`[A2A_RESPONSE]   - taskId: ${taskId}`);
+    log(`[A2A_RESPONSE]   - messageId: ${messageId}`);
+    log(`[A2A_RESPONSE]   - append: ${append}`);
+    log(`[A2A_RESPONSE]   - final: ${final}`);
+    log(`[A2A_RESPONSE]   - text length: ${text?.length ?? 0}`);
+    log(`[A2A_RESPONSE]   - files count: ${files?.length ?? 0}`);
+    log(`[A2A_RESPONSE] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_RESPONSE] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_RESPONSE] ✅ Message sent successfully`);
+}
+/**
+ * Send an A2A task status update.
+ * Follows A2A protocol standard format with nested status object.
+ */
+export async function sendStatusUpdate(params) {
+    const { config, sessionId, taskId, messageId, text, state } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build status update event following A2A protocol standard
+    const statusUpdate = {
+        taskId,
+        kind: "status-update",
+        final: false, // Status updates should not end the stream
+        status: {
+            message: {
+                role: "agent",
+                parts: [
+                    {
+                        kind: "text",
+                        text,
+                    },
+                ],
+            },
+            state,
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: statusUpdate,
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_STATUS] 📤 Sending A2A status-update:`);
+    log(`[A2A_STATUS]   - sessionId: ${sessionId}`);
+    log(`[A2A_STATUS]   - taskId: ${taskId}`);
+    log(`[A2A_STATUS]   - messageId: ${messageId}`);
+    log(`[A2A_STATUS]   - state: ${state}`);
+    log(`[A2A_STATUS]   - text: "${text}"`);
+    log(`[A2A_STATUS] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_STATUS] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_STATUS] ✅ Status update sent successfully`);
+}
+/**
+ * Send a command as an artifact update (final=false).
+ */
+export async function sendCommand(params) {
+    const { config, sessionId, taskId, messageId, command } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build artifact update with command as data
+    // Wrap command in commands array as per protocol requirement
+    const artifact = {
+        taskId,
+        kind: "artifact-update",
+        append: false,
+        lastChunk: true,
+        final: false, // Commands are not final
+        artifact: {
+            artifactId: uuidv4(),
+            parts: [
+                {
+                    kind: "data",
+                    data: {
+                        commands: [command],
+                    },
+                },
+            ],
+        },
+    };
+    // Build JSON-RPC response
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: artifact,
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    // 📋 Log complete response body
+    log(`[A2A_COMMAND] 📤 Sending A2A command:`);
+    log(`[A2A_COMMAND]   - sessionId: ${sessionId}`);
+    log(`[A2A_COMMAND]   - taskId: ${taskId}`);
+    log(`[A2A_COMMAND]   - messageId: ${messageId}`);
+    log(`[A2A_COMMAND]   - command: ${command.header.namespace}::${command.header.name}`);
+    log(`[A2A_COMMAND] 📦 Complete outbound message:`);
+    log(JSON.stringify(outboundMessage, null, 2));
+    log(`[A2A_COMMAND] 📦 JSON-RPC response body:`);
+    log(JSON.stringify(jsonRpcResponse, null, 2));
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`[A2A_COMMAND] ✅ Command sent successfully`);
+}
+/**
+ * Send a clearContext response.
+ */
+export async function sendClearContextResponse(params) {
+    const { config, sessionId, messageId } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for clearContext
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            status: {
+                state: "cleared",
+            },
+        },
+        error: {
+            code: 0,
+            // Note: Using any to bypass type check as the response format differs from standard A2A types
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId: sessionId, // Use sessionId as taskId for clearContext
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`Sent clearContext response: sessionId=${sessionId}`);
+}
+/**
+ * Send a tasks/cancel response.
+ */
+export async function sendTasksCancelResponse(params) {
+    const { config, sessionId, taskId, messageId } = params;
+    const runtime = getXYRuntime();
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Build JSON-RPC response for tasks/cancel
+    // Note: Using any to bypass type check as the response format differs from standard A2A types
+    const jsonRpcResponse = {
+        jsonrpc: "2.0",
+        id: messageId,
+        result: {
+            id: taskId,
+            status: {
+                state: "canceled",
+            },
+        },
+        error: {
+            code: 0,
+            message: "",
+        },
+    };
+    // Send via WebSocket
+    const wsManager = getXYWebSocketManager(config);
+    const outboundMessage = {
+        msgType: "agent_response",
+        agentId: config.agentId,
+        sessionId,
+        taskId,
+        msgDetail: JSON.stringify(jsonRpcResponse),
+    };
+    await wsManager.sendMessage(sessionId, outboundMessage);
+    log(`Sent tasks/cancel response: sessionId=${sessionId}, taskId=${taskId}`);
+}