@ynhcj/xiaoyi-channel 0.0.1-beta

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { xyPlugin } from "./src/channel.js";
+/**
+ * Xiaoyi Channel Plugin Entry Point.
+ * Exports the plugin for OpenClaw to load.
+ * Located at root level following feishu pattern for proper plugin registration.
+ */
+declare const plugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: import("openclaw/plugin-sdk").OpenClawPluginConfigSchema;
+    register(api: OpenClawPluginApi): void;
+};
+export default plugin;
+export { xyPlugin };

package/dist/index.js

@@ -0,0 +1,21 @@
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { xyPlugin } from "./src/channel.js";
+import { setXYRuntime } from "./src/runtime.js";
+/**
+ * Xiaoyi Channel Plugin Entry Point.
+ * Exports the plugin for OpenClaw to load.
+ * Located at root level following feishu pattern for proper plugin registration.
+ */
+const plugin = {
+    id: "xiaoyi-channel",
+    name: "Xiaoyi Channel",
+    description: "Xiaoyi channel plugin - Xiaoyi A2A protocol integration",
+    configSchema: emptyPluginConfigSchema(),
+    register(api) {
+        setXYRuntime(api.runtime);
+        api.registerChannel({ plugin: xyPlugin });
+    },
+};
+export default plugin;
+// Also export the plugin directly for testing
+export { xyPlugin };

package/dist/src/bot.d.ts

@@ -0,0 +1,17 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { A2AJsonRpcRequest } from "./types.js";
+/**
+ * Parameters for handling an XY message.
+ */
+export interface HandleXYMessageParams {
+    cfg: ClawdbotConfig;
+    runtime: RuntimeEnv;
+    message: A2AJsonRpcRequest;
+    accountId: string;
+}
+/**
+ * Handle an incoming A2A message.
+ * This is the main entry point for message processing.
+ * Runtime is expected to be validated before calling this function.
+ */
+export declare function handleXYMessage(params: HandleXYMessageParams): Promise<void>;

package/dist/src/bot.js

@@ -0,0 +1,260 @@
+import { getXYRuntime } from "./runtime.js";
+import { createXYReplyDispatcher } from "./reply-dispatcher.js";
+import { parseA2AMessage, extractTextFromParts, extractFileParts, extractPushId } from "./parser.js";
+import { downloadFilesFromParts } from "./file-download.js";
+import { resolveXYConfig } from "./config.js";
+import { sendStatusUpdate, sendClearContextResponse, sendTasksCancelResponse } from "./formatter.js";
+import { registerSession, unregisterSession } from "./tools/session-manager.js";
+import { configManager } from "./utils/config-manager.js";
+/**
+ * Handle an incoming A2A message.
+ * This is the main entry point for message processing.
+ * Runtime is expected to be validated before calling this function.
+ */
+export async function handleXYMessage(params) {
+    const { cfg, runtime, message, accountId } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    // Get runtime (already validated in monitor.ts, but get reference for use)
+    const core = getXYRuntime();
+    try {
+        // Check for special messages BEFORE parsing (these have different param structures)
+        const messageMethod = message.method;
+        log(`[BOT-ENTRY] <<<<<<< Received message with method: ${messageMethod}, id: ${message.id} >>>>>>>`);
+        log(`[BOT-ENTRY] Stack trace for debugging:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+        // Handle clearContext messages (params only has sessionId)
+        if (messageMethod === "clearContext" || messageMethod === "clear_context") {
+            const sessionId = message.params?.sessionId;
+            if (!sessionId) {
+                throw new Error("clearContext request missing sessionId in params");
+            }
+            log(`Clear context request for session ${sessionId}`);
+            const config = resolveXYConfig(cfg);
+            await sendClearContextResponse({
+                config,
+                sessionId,
+                messageId: message.id,
+            });
+            return;
+        }
+        // Handle tasks/cancel messages
+        if (messageMethod === "tasks/cancel" || messageMethod === "tasks_cancel") {
+            const sessionId = message.params?.sessionId;
+            const taskId = message.params?.id || message.id;
+            if (!sessionId) {
+                throw new Error("tasks/cancel request missing sessionId in params");
+            }
+            log(`Tasks cancel request for session ${sessionId}, task ${taskId}`);
+            const config = resolveXYConfig(cfg);
+            await sendTasksCancelResponse({
+                config,
+                sessionId,
+                taskId,
+                messageId: message.id,
+            });
+            return;
+        }
+        // Parse the A2A message (for regular messages)
+        const parsed = parseA2AMessage(message);
+        // Extract and update push_id if present
+        const pushId = extractPushId(parsed.parts);
+        if (pushId) {
+            log(`[BOT] 📌 Extracted push_id from user message`);
+            log(`[BOT]   - Session ID: ${parsed.sessionId}`);
+            log(`[BOT]   - Push ID preview: ${pushId.substring(0, 20)}...`);
+            log(`[BOT]   - Full push_id: ${pushId}`);
+            configManager.updatePushId(parsed.sessionId, pushId);
+        }
+        else {
+            log(`[BOT] ℹ️  No push_id found in message, will use config default`);
+        }
+        // Resolve configuration (needed for status updates)
+        const config = resolveXYConfig(cfg);
+        // ✅ Resolve agent route (following feishu pattern)
+        // accountId is "default" for XY (single account mode)
+        // Use sessionId as peer.id to ensure all messages in the same session share context
+        let route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "xiaoyi-channel",
+            accountId, // "default"
+            peer: {
+                kind: "direct",
+                id: parsed.sessionId, // ✅ Use sessionId to share context within the same conversation session
+            },
+        });
+        log(`xy: resolved route accountId=${route.accountId}, sessionKey=${route.sessionKey}`);
+        // Register session context for tools
+        log(`[BOT] 📝 About to register session for tools...`);
+        log(`[BOT]   - sessionKey: ${route.sessionKey}`);
+        log(`[BOT]   - sessionId: ${parsed.sessionId}`);
+        log(`[BOT]   - taskId: ${parsed.taskId}`);
+        registerSession(route.sessionKey, {
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            agentId: route.accountId,
+        });
+        log(`[BOT] ✅ Session registered for tools`);
+        // Extract text and files from parts
+        const text = extractTextFromParts(parsed.parts);
+        const fileParts = extractFileParts(parsed.parts);
+        // Download files if present (using core's media download)
+        const mediaList = await downloadFilesFromParts(fileParts);
+        // Build media payload for inbound context (following feishu pattern)
+        const mediaPayload = buildXYMediaPayload(mediaList);
+        // Resolve envelope format options (following feishu pattern)
+        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+        // Build message body with speaker prefix (following feishu pattern)
+        let messageBody = text || "";
+        // Add speaker prefix for clarity
+        const speaker = parsed.sessionId;
+        messageBody = `${speaker}: ${messageBody}`;
+        // Format agent envelope (following feishu pattern)
+        const body = core.channel.reply.formatAgentEnvelope({
+            channel: "xiaoyi-channel",
+            from: speaker,
+            timestamp: new Date(),
+            envelope: envelopeOptions,
+            body: messageBody,
+        });
+        // ✅ Finalize inbound context (following feishu pattern)
+        // Use route.accountId and route.sessionKey instead of parsed fields
+        const ctxPayload = core.channel.reply.finalizeInboundContext({
+            Body: body,
+            RawBody: text || "",
+            CommandBody: text || "",
+            From: parsed.sessionId,
+            To: parsed.sessionId, // ✅ Simplified: use sessionId as target (context is managed by SessionKey)
+            SessionKey: route.sessionKey, // ✅ Use route.sessionKey
+            AccountId: route.accountId, // ✅ Use route.accountId ("default")
+            ChatType: "direct",
+            GroupSubject: undefined,
+            SenderName: parsed.sessionId,
+            SenderId: parsed.sessionId,
+            Provider: "xiaoyi-channel",
+            Surface: "xiaoyi-channel",
+            MessageSid: parsed.messageId,
+            Timestamp: Date.now(),
+            WasMentioned: false,
+            CommandAuthorized: true,
+            OriginatingChannel: "xiaoyi-channel",
+            OriginatingTo: parsed.sessionId, // Original message target
+            ReplyToBody: undefined, // A2A protocol doesn't support reply/quote
+            ...mediaPayload,
+        });
+        // Send initial status update immediately after parsing message
+        log(`[STATUS] Sending initial status update for session ${parsed.sessionId}`);
+        void sendStatusUpdate({
+            config,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            text: "任务正在处理中，请稍后~",
+            state: "working",
+        }).catch((err) => {
+            error(`Failed to send initial status update:`, err);
+        });
+        // Create reply dispatcher (following feishu pattern)
+        log(`[BOT-DISPATCHER] 🎯 Creating reply dispatcher for session=${parsed.sessionId}, taskId=${parsed.taskId}, messageId=${parsed.messageId}`);
+        const { dispatcher, replyOptions, markDispatchIdle, startStatusInterval } = createXYReplyDispatcher({
+            cfg,
+            runtime,
+            sessionId: parsed.sessionId,
+            taskId: parsed.taskId,
+            messageId: parsed.messageId,
+            accountId: route.accountId, // ✅ Use route.accountId
+        });
+        log(`[BOT-DISPATCHER] ✅ Reply dispatcher created successfully`);
+        // Start status update interval (will send updates every 60 seconds)
+        // Interval will be automatically stopped when onIdle/onCleanup is triggered
+        startStatusInterval();
+        log(`xy: dispatching to agent (session=${parsed.sessionId})`);
+        // Dispatch to OpenClaw core using correct API (following feishu pattern)
+        log(`[BOT] 🚀 Starting dispatcher with session: ${route.sessionKey}`);
+        await core.channel.reply.withReplyDispatcher({
+            dispatcher,
+            onSettled: () => {
+                log(`[BOT] 🏁 onSettled called for session: ${route.sessionKey}`);
+                log(`[BOT]   - About to unregister session...`);
+                markDispatchIdle();
+                // Unregister session context when done
+                unregisterSession(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered in onSettled`);
+            },
+            run: () => core.channel.reply.dispatchReplyFromConfig({
+                ctx: ctxPayload,
+                cfg,
+                dispatcher,
+                replyOptions,
+            }),
+        });
+        log(`[BOT] ✅ Dispatcher completed for session: ${parsed.sessionId}`);
+        log(`xy: dispatch complete (session=${parsed.sessionId})`);
+    }
+    catch (err) {
+        // ✅ Only log error, don't re-throw to prevent gateway restart
+        error("Failed to handle XY message:", err);
+        runtime.error?.(`xy: Failed to handle message: ${String(err)}`);
+        log(`[BOT] ❌ Error occurred, attempting cleanup...`);
+        // Try to unregister session on error (if route was established)
+        try {
+            const core = getXYRuntime();
+            const params = message.params;
+            const sessionId = params?.sessionId;
+            if (sessionId) {
+                log(`[BOT] 🧹 Cleaning up session after error: ${sessionId}`);
+                const route = core.channel.routing.resolveAgentRoute({
+                    cfg,
+                    channel: "xiaoyi-channel",
+                    accountId,
+                    peer: {
+                        kind: "direct",
+                        id: sessionId, // ✅ Use sessionId for cleanup consistency
+                    },
+                });
+                log(`[BOT]   - Unregistering session: ${route.sessionKey}`);
+                unregisterSession(route.sessionKey);
+                log(`[BOT] ✅ Session unregistered after error`);
+            }
+        }
+        catch (cleanupErr) {
+            log(`[BOT] ⚠️  Cleanup failed:`, cleanupErr);
+            // Ignore cleanup errors
+        }
+        // ❌ Don't re-throw: message processing error should not affect gateway stability
+    }
+}
+/**
+ * Build media payload for inbound context.
+ * Following feishu pattern: buildFeishuMediaPayload().
+ */
+function buildXYMediaPayload(mediaList) {
+    const first = mediaList[0];
+    const mediaPaths = mediaList.map((media) => media.path);
+    const mediaTypes = mediaList.map((media) => media.mimeType).filter(Boolean);
+    return {
+        MediaPath: first?.path,
+        MediaType: first?.mimeType,
+        MediaUrl: first?.path,
+        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+    };
+}
+/**
+ * Infer OpenClaw media type from file type string.
+ */
+function inferMediaType(fileType) {
+    const lower = fileType.toLowerCase();
+    if (lower.includes("image") || /\.(jpg|jpeg|png|gif|bmp|webp)$/i.test(lower)) {
+        return "image";
+    }
+    if (lower.includes("video") || /\.(mp4|avi|mov|mkv|webm)$/i.test(lower)) {
+        return "video";
+    }
+    if (lower.includes("audio") || /\.(mp3|wav|ogg|m4a)$/i.test(lower)) {
+        return "audio";
+    }
+    return "file";
+}

package/dist/src/channel.d.ts

@@ -0,0 +1,6 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk";
+/**
+ * Xiaoyi Channel Plugin for OpenClaw.
+ * Implements Xiaoyi A2A protocol with dual WebSocket connections.
+ */
+export declare const xyPlugin: ChannelPlugin;

package/dist/src/channel.js

@@ -0,0 +1,87 @@
+import { resolveXYConfig, listXYAccountIds, getDefaultXYAccountId } from "./config.js";
+import { xyConfigSchema } from "./config-schema.js";
+import { xyOutbound } from "./outbound.js";
+import { xyOnboardingAdapter } from "./onboarding.js";
+import { locationTool } from "./tools/location-tool.js";
+import { noteTool } from "./tools/note-tool.js";
+import { searchNoteTool } from "./tools/search-note-tool.js";
+import { calendarTool } from "./tools/calendar-tool.js";
+/**
+ * Xiaoyi Channel Plugin for OpenClaw.
+ * Implements Xiaoyi A2A protocol with dual WebSocket connections.
+ */
+export const xyPlugin = {
+    id: "xiaoyi-channel",
+    meta: {
+        id: "xiaoyi-channel",
+        label: "Xiaoyi Channel",
+        selectionLabel: "Xiaoyi Channel (小艺)",
+        docsPath: "/channels/xiaoyi-channel",
+        blurb: "小艺 A2A 协议支持，双 WebSocket 长连接",
+        order: 85,
+    },
+    agentPrompt: {
+        messageToolHints: () => [
+            "- xiaoyi targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `default`",
+            "- sendMedia requires a text reply"
+        ],
+    },
+    capabilities: {
+        chatTypes: ["direct"], // Only private chat (no group support)
+        polls: false,
+        threads: false,
+        media: true,
+        reactions: false,
+        edit: false,
+        reply: true,
+    },
+    config: {
+        listAccountIds: listXYAccountIds,
+        resolveAccount: resolveXYConfig,
+        defaultAccountId: getDefaultXYAccountId,
+    },
+    configSchema: {
+        schema: xyConfigSchema,
+    },
+    outbound: xyOutbound,
+    onboarding: xyOnboardingAdapter,
+    agentTools: [locationTool, noteTool, searchNoteTool, calendarTool],
+    messaging: {
+        normalizeTarget: (raw) => {
+            const trimmed = raw.trim();
+            if (!trimmed)
+                return undefined;
+            return trimmed;
+        },
+        targetResolver: {
+            looksLikeId: (raw) => {
+                // 信任所有非空字符串作为有效的 sessionId
+                const trimmed = raw.trim();
+                return trimmed.length > 0;
+            },
+            hint: "<sessionId>",
+        },
+    },
+    reload: {
+        configPrefixes: ["channels.xiaoyi-channel"],
+    },
+    // Gateway adapter for receiving messages
+    gateway: {
+        async startAccount(context) {
+            const { monitorXYProvider } = await import("./monitor.js");
+            const account = resolveXYConfig(context.cfg);
+            context.setStatus?.({
+                accountId: context.accountId,
+                wsUrl1: account.wsUrl1,
+                wsUrl2: account.wsUrl2,
+            });
+            context.log?.info(`[${context.accountId}] starting xiaoyi channel (wsUrl1: ${account.wsUrl1}, wsUrl2: ${account.wsUrl2})`);
+            return monitorXYProvider({
+                config: context.cfg,
+                runtime: context.runtime,
+                abortSignal: context.abortSignal,
+                accountId: context.accountId,
+            });
+        },
+    },
+};

package/dist/src/client.d.ts

@@ -0,0 +1,35 @@
+import { XYWebSocketManager } from "./websocket.js";
+import type { XYChannelConfig } from "./types.js";
+import type { RuntimeEnv } from "openclaw/plugin-sdk";
+/**
+ * Set the runtime for logging in client module.
+ */
+export declare function setClientRuntime(rt: RuntimeEnv | undefined): void;
+/**
+ * Get or create a WebSocket manager for the given configuration.
+ * Reuses existing managers if config matches.
+ */
+export declare function getXYWebSocketManager(config: XYChannelConfig): XYWebSocketManager;
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export declare function removeXYWebSocketManager(config: XYChannelConfig): void;
+/**
+ * Clear all cached WebSocket managers.
+ */
+export declare function clearXYWebSocketManagers(): void;
+/**
+ * Get the number of cached managers.
+ */
+export declare function getCachedManagerCount(): number;
+/**
+ * Diagnose all cached WebSocket managers.
+ * Helps identify connection issues and orphan connections.
+ */
+export declare function diagnoseAllManagers(): void;
+/**
+ * Clean up orphan connections across all managers.
+ * Returns the number of managers that had orphan connections.
+ */
+export declare function cleanupOrphanConnections(): number;

package/dist/src/client.js

@@ -0,0 +1,147 @@
+// WebSocket client cache management
+// Follows feishu/client.ts pattern for caching client instances
+import { XYWebSocketManager } from "./websocket.js";
+// Runtime reference for logging
+let runtime;
+/**
+ * Set the runtime for logging in client module.
+ */
+export function setClientRuntime(rt) {
+    runtime = rt;
+}
+/**
+ * Global cache for WebSocket managers.
+ * Key format: `${apiKey}-${agentId}`
+ */
+const wsManagerCache = new Map();
+/**
+ * Get or create a WebSocket manager for the given configuration.
+ * Reuses existing managers if config matches.
+ */
+export function getXYWebSocketManager(config) {
+    const cacheKey = `${config.apiKey}-${config.agentId}`;
+    let cached = wsManagerCache.get(cacheKey);
+    if (cached && cached.isConfigMatch(config)) {
+        const log = runtime?.log ?? console.log;
+        log(`[WS-MANAGER-CACHE] ✅ Reusing cached WebSocket manager: ${cacheKey}, total managers: ${wsManagerCache.size}`);
+        return cached;
+    }
+    // Create new manager
+    const log = runtime?.log ?? console.log;
+    log(`[WS-MANAGER-CACHE] 🆕 Creating new WebSocket manager: ${cacheKey}, total managers before: ${wsManagerCache.size}`);
+    cached = new XYWebSocketManager(config, runtime);
+    wsManagerCache.set(cacheKey, cached);
+    log(`[WS-MANAGER-CACHE] 📊 Total managers after creation: ${wsManagerCache.size}`);
+    return cached;
+}
+/**
+ * Remove a specific WebSocket manager from cache.
+ * Disconnects the manager and removes it from the cache.
+ */
+export function removeXYWebSocketManager(config) {
+    const cacheKey = `${config.apiKey}-${config.agentId}`;
+    const manager = wsManagerCache.get(cacheKey);
+    if (manager) {
+        console.log(`🗑️  [WS-MANAGER-CACHE] Removing manager from cache: ${cacheKey}`);
+        manager.disconnect();
+        wsManagerCache.delete(cacheKey);
+        console.log(`🗑️  [WS-MANAGER-CACHE] Manager removed, remaining managers: ${wsManagerCache.size}`);
+    }
+    else {
+        console.log(`⚠️  [WS-MANAGER-CACHE] Manager not found in cache: ${cacheKey}`);
+    }
+}
+/**
+ * Clear all cached WebSocket managers.
+ */
+export function clearXYWebSocketManagers() {
+    const log = runtime?.log ?? console.log;
+    log("Clearing all WebSocket manager caches");
+    for (const manager of wsManagerCache.values()) {
+        manager.disconnect();
+    }
+    wsManagerCache.clear();
+}
+/**
+ * Get the number of cached managers.
+ */
+export function getCachedManagerCount() {
+    return wsManagerCache.size;
+}
+/**
+ * Diagnose all cached WebSocket managers.
+ * Helps identify connection issues and orphan connections.
+ */
+export function diagnoseAllManagers() {
+    console.log("========================================");
+    console.log("📊 WebSocket Manager Global Diagnostics");
+    console.log("========================================");
+    console.log(`Total cached managers: ${wsManagerCache.size}`);
+    console.log("");
+    if (wsManagerCache.size === 0) {
+        console.log("ℹ️  No managers in cache");
+        console.log("========================================");
+        return;
+    }
+    let orphanCount = 0;
+    wsManagerCache.forEach((manager, key) => {
+        const diag = manager.getConnectionDiagnostics();
+        console.log(`📌 Manager: ${key}`);
+        console.log(`   Shutting down: ${diag.isShuttingDown}`);
+        console.log(`   Total event listeners on manager: ${diag.totalEventListeners}`);
+        // Server 1
+        console.log(`   🔌 Server1:`);
+        console.log(`      - Exists: ${diag.server1.exists}`);
+        console.log(`      - ReadyState: ${diag.server1.readyState}`);
+        console.log(`      - State connected/ready: ${diag.server1.stateConnected}/${diag.server1.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.server1.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.server1.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.server1.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.server1.hasReconnectTimer}`);
+        if (diag.server1.isOrphan) {
+            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            orphanCount++;
+        }
+        // Server 2
+        console.log(`   🔌 Server2:`);
+        console.log(`      - Exists: ${diag.server2.exists}`);
+        console.log(`      - ReadyState: ${diag.server2.readyState}`);
+        console.log(`      - State connected/ready: ${diag.server2.stateConnected}/${diag.server2.stateReady}`);
+        console.log(`      - Reconnect attempts: ${diag.server2.reconnectAttempts}`);
+        console.log(`      - Listeners on WebSocket: ${diag.server2.listenerCount}`);
+        console.log(`      - Heartbeat active: ${diag.server2.heartbeatActive}`);
+        console.log(`      - Has reconnect timer: ${diag.server2.hasReconnectTimer}`);
+        if (diag.server2.isOrphan) {
+            console.log(`      ⚠️  ORPHAN CONNECTION DETECTED!`);
+            orphanCount++;
+        }
+        console.log("");
+    });
+    if (orphanCount > 0) {
+        console.log(`⚠️  Total orphan connections found: ${orphanCount}`);
+        console.log(`💡 Suggestion: These connections should be cleaned up`);
+    }
+    else {
+        console.log(`✅ No orphan connections found`);
+    }
+    console.log("========================================");
+}
+/**
+ * Clean up orphan connections across all managers.
+ * Returns the number of managers that had orphan connections.
+ */
+export function cleanupOrphanConnections() {
+    let cleanedCount = 0;
+    wsManagerCache.forEach((manager, key) => {
+        const diag = manager.getConnectionDiagnostics();
+        if (diag.server1.isOrphan || diag.server2.isOrphan) {
+            console.log(`🧹 Cleaning up orphan connections in manager: ${key}`);
+            manager.disconnect();
+            cleanedCount++;
+        }
+    });
+    if (cleanedCount > 0) {
+        console.log(`🧹 Cleaned up ${cleanedCount} manager(s) with orphan connections`);
+    }
+    return cleanedCount;
+}

package/dist/src/config-schema.d.ts

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