@ynhcj/xiaoyi 2.5.5 → 2.5.7

package/dist/xy-reply-dispatcher.js

@@ -0,0 +1,308 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createXYReplyDispatcher = createXYReplyDispatcher;
+const runtime_js_1 = require("./runtime.js");
+const xy_formatter_js_1 = require("./xy-formatter.js");
+const xy_config_js_1 = require("./xy-config.js");
+/**
+ * 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.
+ */
+function createXYReplyDispatcher(params) {
+    const { cfg, runtime, sessionId, taskId, messageId, accountId } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    log(`[DISPATCHER-CREATE] ******* Creating dispatcher for session=${sessionId}, taskId=${taskId}, messageId=${messageId} *******`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    log(`[DISPATCHER-CREATE] ======== Creating reply dispatcher ========`);
+    log(`[DISPATCHER-CREATE] sessionId: ${sessionId}, taskId: ${taskId}, messageId: ${messageId}`);
+    log(`[DISPATCHER-CREATE] Stack trace:`, new Error().stack?.split('\n').slice(1, 4).join('\n'));
+    // Get OpenClaw PluginRuntime (not XiaoYiRuntime)
+    const xiaoYiRuntime = (0, runtime_js_1.getXiaoYiRuntime)();
+    const core = xiaoYiRuntime.getPluginRuntime();
+    // Resolve configuration
+    const config = (0, xy_config_js_1.resolveXYConfig)(cfg);
+    // Reply prefix context: not imported at runtime to avoid openclaw/plugin-sdk
+    // module resolution issues in the CJS require chain. For a bot-to-bot A2A
+    // channel the response prefix (model name badge) is not needed.
+    const prefixContext = { responsePrefix: undefined, responsePrefixContextProvider: undefined, onModelSelected: undefined };
+    // Status update interval (every 60 seconds)
+    let statusUpdateInterval = null;
+    // Track if we've sent any response
+    let hasSentResponse = false;
+    // Track if we've sent the final empty message
+    let finalSent = false;
+    // Accumulate all text from deliver calls
+    let accumulatedText = "";
+    /**
+     * Start the status update interval
+     * Call this immediately after creating the dispatcher
+     */
+    const startStatusInterval = () => {
+        log(`[STATUS INTERVAL] Starting interval for session ${sessionId}, taskId=${taskId}`);
+        statusUpdateInterval = setInterval(() => {
+            log(`[STATUS INTERVAL] Triggering status update for session ${sessionId}, taskId=${taskId}`);
+            void (0, xy_formatter_js_1.sendStatusUpdate)({
+                config,
+                sessionId,
+                taskId,
+                messageId,
+                text: "任务正在处理中，请稍后~",
+                state: "working",
+            }).catch((err) => {
+                error(`Failed to send status update:`, err);
+            });
+        }, 30000); // 30 seconds
+    };
+    /**
+     * Stop the status update interval
+     */
+    const stopStatusInterval = () => {
+        if (statusUpdateInterval) {
+            log(`[STATUS INTERVAL] Stopping interval for session ${sessionId}, taskId=${taskId}`);
+            clearInterval(statusUpdateInterval);
+            statusUpdateInterval = null;
+            log(`[STATUS INTERVAL] Stopped interval for session ${sessionId}, taskId=${taskId}`);
+        }
+    };
+    const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({
+        responsePrefix: prefixContext.responsePrefix,
+        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, accountId),
+        onReplyStart: () => {
+            log(`[REPLY START] Reply started for session ${sessionId}, taskId=${taskId}`);
+            // Status update interval is now managed externally
+        },
+        deliver: async (payload, info) => {
+            const text = payload.text ?? "";
+            // 🔍 Debug logging
+            log(`[DELIVER] sessionId=${sessionId}, info.kind=${info?.kind}, text.length=${text.length}, text="${text.slice(0, 200)}"`);
+            log(`[DELIVER] payload keys: ${Object.keys(payload).join(", ")}`);
+            if (payload.mediaUrls) {
+                log(`[DELIVER] mediaUrls: ${payload.mediaUrls.length} files`);
+            }
+            try {
+                // Skip empty messages
+                if (!text.trim()) {
+                    log(`[DELIVER SKIP] Empty text, skipping`);
+                    return;
+                }
+                // Accumulate text instead of sending immediately
+                accumulatedText += text;
+                hasSentResponse = true;
+                log(`[DELIVER ACCUMULATE] Accumulated text, current length=${accumulatedText.length}`);
+                // Also stream text as reasoningText for real-time display
+                await (0, xy_formatter_js_1.sendReasoningTextUpdate)({
+                    config,
+                    sessionId,
+                    taskId,
+                    messageId,
+                    text,
+                });
+                log(`[DELIVER] ✅ Sent deliver text as reasoningText update`);
+            }
+            catch (deliverError) {
+                error(`Failed to deliver message:`, deliverError);
+            }
+        },
+        onError: async (err, info) => {
+            runtime.error?.(`xy: ${info.kind} reply failed: ${String(err)}`);
+            // Stop status updates
+            stopStatusInterval();
+            // Send error status if we haven't sent any response yet
+            if (!hasSentResponse) {
+                try {
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "处理失败，请稍后重试",
+                        state: "failed",
+                    });
+                }
+                catch (statusError) {
+                    error(`Failed to send error status:`, statusError);
+                }
+            }
+        },
+        onIdle: async () => {
+            log(`[ON_IDLE] Reply idle for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+            // Send accumulated text with append=false and final=true
+            if (hasSentResponse && !finalSent) {
+                log(`[ON_IDLE] Sending accumulated text, length=${accumulatedText.length}`);
+                try {
+                    // Send status update before final message
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理已完成~",
+                        state: "completed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent completion status update`);
+                    await (0, xy_formatter_js_1.sendA2AResponse)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: accumulatedText,
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] Sent accumulated text`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send accumulated text:`, err);
+                }
+            }
+            else {
+                log(`[ON_IDLE] Skipping final message: hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+                // Task was interrupted - send failure status and error response
+                try {
+                    await (0, xy_formatter_js_1.sendStatusUpdate)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务处理中断了~",
+                        state: "failed",
+                    });
+                    log(`[ON_IDLE] ✅ Sent failure status update`);
+                    await (0, xy_formatter_js_1.sendA2AResponse)({
+                        config,
+                        sessionId,
+                        taskId,
+                        messageId,
+                        text: "任务执行异常，请重试~",
+                        append: false,
+                        final: true,
+                    });
+                    finalSent = true;
+                    log(`[ON_IDLE] ✅ Sent error response`);
+                }
+                catch (err) {
+                    error(`[ON_IDLE] Failed to send failure status and error response:`, err);
+                }
+            }
+            // Stop status updates
+            stopStatusInterval();
+        },
+        onCleanup: () => {
+            log(`[ON_CLEANUP] Reply cleanup for session ${sessionId}, hasSentResponse=${hasSentResponse}, finalSent=${finalSent}`);
+        },
+    });
+    return {
+        dispatcher,
+        replyOptions: {
+            ...replyOptions,
+            onModelSelected: prefixContext.onModelSelected,
+            // 🔧 Tool execution start callback
+            onToolStart: async ({ name, phase }) => {
+                log(`[TOOL START] 🔧 Tool execution started/updated: name=${name}, phase=${phase}, session=${sessionId}, taskId=${taskId}`);
+                if (phase === "start") {
+                    const toolName = name || "unknown";
+                    try {
+                        await (0, xy_formatter_js_1.sendStatusUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: `正在使用工具: ${toolName}...`,
+                            state: "working",
+                        });
+                        log(`[TOOL START] ✅ Sent status update for tool start: ${toolName}`);
+                    }
+                    catch (err) {
+                        error(`[TOOL START] ❌ Failed to send tool start status:`, err);
+                    }
+                }
+            },
+            // 🔧 Tool execution result callback
+            onToolResult: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[TOOL RESULT] 🔧 Tool execution result received: session=${sessionId}, taskId=${taskId}`);
+                log(`[TOOL RESULT]   - text.length=${text.length}`);
+                log(`[TOOL RESULT]   - hasMedia=${hasMedia}`);
+                log(`[TOOL RESULT]   - isError=${payload.isError}`);
+                if (text.length > 0) {
+                    log(`[TOOL RESULT]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0 || hasMedia) {
+                        const resultText = text.length > 0 ? text : "工具执行完成";
+                        await (0, xy_formatter_js_1.sendStatusUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text: resultText,
+                            state: "working",
+                        });
+                        log(`[TOOL RESULT] ✅ Sent tool result as status update`);
+                    }
+                }
+                catch (err) {
+                    error(`[TOOL RESULT] ❌ Failed to send tool result status:`, err);
+                }
+            },
+            // 🧠 Reasoning/thinking process streaming callback
+            onReasoningStream: async (payload) => {
+                const text = payload.text ?? "";
+                log(`[REASONING STREAM] 🧠 Reasoning/thinking chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[REASONING STREAM]   - text.length=${text.length}`);
+                if (text.length > 0) {
+                    log(`[REASONING STREAM]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                // try {
+                //   if (text.length > 0) {
+                //     await sendReasoningTextUpdate({
+                //       config,
+                //       sessionId,
+                //       taskId,
+                //       messageId,
+                //       text,
+                //     });
+                //     log(`[REASONING STREAM] ✅ Sent reasoning chunk as reasoningText update`);
+                //   }
+                // } catch (err) {
+                //   error(`[REASONING STREAM] ❌ Failed to send reasoning chunk reasoningText:`, err);
+                // }
+            },
+            // 📝 Partial reply streaming callback (real-time preview)
+            onPartialReply: async (payload) => {
+                const text = payload.text ?? "";
+                const hasMedia = Boolean(payload.mediaUrl || (payload.mediaUrls?.length ?? 0) > 0);
+                log(`[PARTIAL REPLY] 📝 Partial reply chunk received: session=${sessionId}, taskId=${taskId}`);
+                log(`[PARTIAL REPLY]   - text.length=${text.length}`);
+                log(`[PARTIAL REPLY]   - hasMedia=${hasMedia}`);
+                if (text.length > 0) {
+                    log(`[PARTIAL REPLY]   - text preview: "${text.slice(0, 200)}"`);
+                }
+                try {
+                    if (text.length > 0) {
+                        await (0, xy_formatter_js_1.sendReasoningTextUpdate)({
+                            config,
+                            sessionId,
+                            taskId,
+                            messageId,
+                            text,
+                            append: false,
+                        });
+                        log(`[PARTIAL REPLY] ✅ Sent partial reply as reasoningText update (append=false)`);
+                    }
+                }
+                catch (err) {
+                    error(`[PARTIAL REPLY] ❌ Failed to send partial reply reasoningText:`, err);
+                }
+            },
+        },
+        markDispatchIdle,
+        startStatusInterval, // Expose this to be called immediately
+        stopStatusInterval, // Expose this for manual control if needed
+    };
+}

package/dist/xy-tools/session-manager.d.ts

@@ -0,0 +1,29 @@
+import type { XiaoYiChannelConfig } from "../types.js";
+export interface SessionContext {
+    config: XiaoYiChannelConfig;
+    sessionId: string;
+    taskId: string;
+    messageId: string;
+    agentId: string;
+}
+/**
+ * Register a session context for tool access.
+ * Should be called when starting to process a message.
+ */
+export declare function registerSession(sessionKey: string, context: SessionContext): void;
+/**
+ * Unregister a session context.
+ * Should be called when message processing is complete.
+ */
+export declare function unregisterSession(sessionKey: string): void;
+/**
+ * Get session context by sessionKey.
+ * Returns null if session not found.
+ */
+export declare function getSessionContext(sessionKey: string): SessionContext | null;
+/**
+ * Get the most recent session context.
+ * This is a fallback for tools that don't have access to sessionKey.
+ * Returns null if no sessions are active.
+ */
+export declare function getLatestSessionContext(): SessionContext | null;

package/dist/xy-tools/session-manager.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSession = registerSession;
+exports.unregisterSession = unregisterSession;
+exports.getSessionContext = getSessionContext;
+exports.getLatestSessionContext = getLatestSessionContext;
+const logger_js_1 = require("../xy-utils/logger.js");
+const config_manager_js_1 = require("../xy-utils/config-manager.js");
+// Map of sessionKey -> SessionContext
+const activeSessions = new Map();
+/**
+ * Register a session context for tool access.
+ * Should be called when starting to process a message.
+ */
+function registerSession(sessionKey, context) {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 📝 Registering session: ${sessionKey}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - taskId: ${context.taskId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - messageId: ${context.messageId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - agentId: ${context.agentId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
+    activeSessions.set(sessionKey, context);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - All session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+}
+/**
+ * Unregister a session context.
+ * Should be called when message processing is complete.
+ */
+function unregisterSession(sessionKey) {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 🗑️  Unregistering session: ${sessionKey}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions before: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Session existed: ${activeSessions.has(sessionKey)}`);
+    // Get session context before deleting to clear associated pushId
+    const context = activeSessions.get(sessionKey);
+    const existed = activeSessions.delete(sessionKey);
+    // Clear cached pushId for this session
+    if (context) {
+        config_manager_js_1.configManager.clearSession(context.sessionId);
+    }
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Deleted: ${existed}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions after: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Remaining session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+}
+/**
+ * Get session context by sessionKey.
+ * Returns null if session not found.
+ */
+function getSessionContext(sessionKey) {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 🔍 Getting session by key: ${sessionKey}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions: ${activeSessions.size}`);
+    const context = activeSessions.get(sessionKey) ?? null;
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Found: ${context !== null}`);
+    if (context) {
+        logger_js_1.logger.log(`[SESSION_MANAGER]   - sessionId: ${context.sessionId}`);
+    }
+    return context;
+}
+/**
+ * Get the most recent session context.
+ * This is a fallback for tools that don't have access to sessionKey.
+ * Returns null if no sessions are active.
+ */
+function getLatestSessionContext() {
+    logger_js_1.logger.log(`[SESSION_MANAGER] 🔍 Getting latest session context`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active sessions count: ${activeSessions.size}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - Active session keys: [${Array.from(activeSessions.keys()).join(", ")}]`);
+    if (activeSessions.size === 0) {
+        logger_js_1.logger.error(`[SESSION_MANAGER]   - ❌ No active sessions found!`);
+        return null;
+    }
+    // Return the last added session
+    const sessions = Array.from(activeSessions.values());
+    const latestSession = sessions[sessions.length - 1];
+    logger_js_1.logger.log(`[SESSION_MANAGER]   - ✅ Found latest session:`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]     - sessionId: ${latestSession.sessionId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]     - taskId: ${latestSession.taskId}`);
+    logger_js_1.logger.log(`[SESSION_MANAGER]     - messageId: ${latestSession.messageId}`);
+    return latestSession;
+}

package/dist/xy-utils/config-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+declare class ConfigManager {
+    private sessionPushIds;
+    private globalPushId;
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId: string, pushId: string): void;
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId?: string): string | null;
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * Clear all cached push IDs.
+     */
+    clear(): void;
+}
+export declare const configManager: ConfigManager;
+export {};

package/dist/xy-utils/config-manager.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = void 0;
+// Dynamic configuration manager for runtime updates
+const logger_js_1 = require("./logger.js");
+/**
+ * Manages dynamic configuration updates that can change at runtime.
+ * Specifically handles pushId which can be updated per-session.
+ */
+class ConfigManager {
+    constructor() {
+        this.sessionPushIds = new Map();
+        this.globalPushId = null;
+    }
+    /**
+     * Update push ID for a specific session.
+     */
+    updatePushId(sessionId, pushId) {
+        if (!pushId) {
+            logger_js_1.logger.warn(`[ConfigManager] Attempted to set empty pushId for session ${sessionId}`);
+            return;
+        }
+        const previous = this.sessionPushIds.get(sessionId);
+        if (previous !== pushId) {
+            logger_js_1.logger.log(`[ConfigManager] ✨ Updated pushId for session ${sessionId}`);
+            logger_js_1.logger.log(`[ConfigManager]   - Previous: ${previous ? previous.substring(0, 20) + '...' : 'none'}`);
+            logger_js_1.logger.log(`[ConfigManager]   - New:      ${pushId.substring(0, 20)}...`);
+            logger_js_1.logger.log(`[ConfigManager]   - Full new pushId: ${pushId}`);
+            this.sessionPushIds.set(sessionId, pushId);
+            this.globalPushId = pushId; // Also update global for backward compatibility
+        }
+    }
+    /**
+     * Get push ID for a session (falls back to global if not found).
+     */
+    getPushId(sessionId) {
+        if (sessionId) {
+            const sessionPushId = this.sessionPushIds.get(sessionId);
+            if (sessionPushId) {
+                return sessionPushId;
+            }
+        }
+        return this.globalPushId;
+    }
+    /**
+     * Clear push ID for a session.
+     */
+    clearSession(sessionId) {
+        this.sessionPushIds.delete(sessionId);
+        logger_js_1.logger.debug(`[ConfigManager] Cleared pushId for session ${sessionId}`);
+    }
+    /**
+     * Clear all cached push IDs.
+     */
+    clear() {
+        this.sessionPushIds.clear();
+        this.globalPushId = null;
+        logger_js_1.logger.debug(`[ConfigManager] Cleared all cached pushIds`);
+    }
+}
+exports.configManager = new ConfigManager();

package/dist/xy-utils/crypto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Calculate SHA256 hash of a buffer.
+ */
+export declare function calculateSHA256(buffer: Buffer): string;
+/**
+ * Calculate SHA256 hash of a string.
+ */
+export declare function calculateSHA256String(text: string): string;

package/dist/xy-utils/crypto.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSHA256 = calculateSHA256;
+exports.calculateSHA256String = calculateSHA256String;
+// Cryptographic utilities
+const crypto_1 = __importDefault(require("crypto"));
+/**
+ * Calculate SHA256 hash of a buffer.
+ */
+function calculateSHA256(buffer) {
+    return crypto_1.default.createHash("sha256").update(buffer).digest("hex");
+}
+/**
+ * Calculate SHA256 hash of a string.
+ */
+function calculateSHA256String(text) {
+    return crypto_1.default.createHash("sha256").update(text, "utf8").digest("hex");
+}

package/dist/xy-utils/logger.d.ts

@@ -0,0 +1,6 @@
+export declare const logger: {
+    log(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, ...args: any[]): void;
+    debug(message: string, ...args: any[]): void;
+};

package/dist/xy-utils/logger.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+// Logging utilities for XY channel
+const runtime_js_1 = require("../runtime.js");
+/**
+ * Log a message using the OpenClaw runtime logger.
+ */
+function logMessage(level, message, ...args) {
+    try {
+        const runtime = (0, runtime_js_1.getXiaoYiRuntime)();
+        const logFn = runtime[level];
+        if (logFn) {
+            const formattedMessage = `[XY] ${message}`;
+            logFn(formattedMessage, ...args);
+        }
+    }
+    catch (error) {
+        // Fallback to console if runtime not available
+        console[level](`[XY] ${message}`, ...args);
+    }
+}
+exports.logger = {
+    log(message, ...args) {
+        logMessage("log", message, ...args);
+    },
+    warn(message, ...args) {
+        logMessage("warn", message, ...args);
+    },
+    error(message, ...args) {
+        logMessage("error", message, ...args);
+    },
+    debug(message, ...args) {
+        // Debug messages go to log level
+        logMessage("log", `[DEBUG] ${message}`, ...args);
+    },
+};

package/dist/xy-utils/session.d.ts

@@ -0,0 +1,34 @@
+import type { SessionBinding, ServerIdentifier } from "../types.js";
+/**
+ * Session-to-server binding cache.
+ * Tracks which WebSocket server each session is bound to.
+ */
+declare class SessionManager {
+    private bindings;
+    /**
+     * Bind a session to a specific server.
+     */
+    bind(sessionId: string, server: ServerIdentifier): void;
+    /**
+     * Get the server binding for a session.
+     */
+    getBinding(sessionId: string): ServerIdentifier | null;
+    /**
+     * Check if a session is bound to a server.
+     */
+    isBound(sessionId: string): boolean;
+    /**
+     * Unbind a session.
+     */
+    unbind(sessionId: string): void;
+    /**
+     * Clear all bindings.
+     */
+    clear(): void;
+    /**
+     * Get all bindings.
+     */
+    getAll(): SessionBinding[];
+}
+export declare const sessionManager: SessionManager;
+export {};

package/dist/xy-utils/session.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionManager = void 0;
+/**
+ * Session-to-server binding cache.
+ * Tracks which WebSocket server each session is bound to.
+ */
+class SessionManager {
+    constructor() {
+        this.bindings = new Map();
+    }
+    /**
+     * Bind a session to a specific server.
+     */
+    bind(sessionId, server) {
+        this.bindings.set(sessionId, {
+            sessionId,
+            server,
+            boundAt: Date.now(),
+        });
+    }
+    /**
+     * Get the server binding for a session.
+     */
+    getBinding(sessionId) {
+        const binding = this.bindings.get(sessionId);
+        return binding ? binding.server : null;
+    }
+    /**
+     * Check if a session is bound to a server.
+     */
+    isBound(sessionId) {
+        return this.bindings.has(sessionId);
+    }
+    /**
+     * Unbind a session.
+     */
+    unbind(sessionId) {
+        this.bindings.delete(sessionId);
+    }
+    /**
+     * Clear all bindings.
+     */
+    clear() {
+        this.bindings.clear();
+    }
+    /**
+     * Get all bindings.
+     */
+    getAll() {
+        return Array.from(this.bindings.values());
+    }
+}
+// Singleton instance
+exports.sessionManager = new SessionManager();