koishi-plugin-bind-bot 2.0.0

package/lib/utils/logger.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerService = void 0;
+/**
+ * 统一的日志服务类
+ * 提供一致的日志接口，支持上下文标签和调试模式
+ */
+class LoggerService {
+    logger;
+    debugMode;
+    defaultContext;
+    /**
+     * 创建日志服务实例
+     * @param logger Koishi Logger 实例
+     * @param debugMode 是否启用调试模式
+     * @param defaultContext 默认上下文标签（可选）
+     */
+    constructor(logger, debugMode = false, defaultContext = '') {
+        this.logger = logger;
+        this.debugMode = debugMode;
+        this.defaultContext = defaultContext;
+    }
+    /**
+     * 设置调试模式
+     */
+    setDebugMode(enabled) {
+        this.debugMode = enabled;
+    }
+    /**
+     * 获取当前调试模式状态
+     */
+    getDebugMode() {
+        return this.debugMode;
+    }
+    /**
+     * 输出调试日志（仅在 debugMode 为 true 时输出）
+     * @param context 上下文标签
+     * @param message 日志消息
+     */
+    debug(context, message) {
+        if (this.debugMode) {
+            const ctx = context || this.defaultContext;
+            this.logger.debug(ctx ? `[${ctx}] ${message}` : message);
+        }
+    }
+    /**
+     * 输出信息日志
+     * @param context 上下文标签
+     * @param message 日志消息
+     * @param forceOutput 强制输出（忽略 debugMode 限制）
+     */
+    info(context, message, forceOutput = false) {
+        // 只有在debugMode开启或forceOutput=true时才输出普通信息
+        if (this.debugMode || forceOutput) {
+            const ctx = context || this.defaultContext;
+            this.logger.info(ctx ? `[${ctx}] ${message}` : message);
+        }
+    }
+    /**
+     * 输出警告日志（总是输出）
+     * @param context 上下文标签
+     * @param message 日志消息
+     */
+    warn(context, message) {
+        const ctx = context || this.defaultContext;
+        this.logger.warn(ctx ? `[${ctx}] ${message}` : message);
+    }
+    /**
+     * 输出错误日志（总是输出）
+     * @param context 上下文标签
+     * @param message 错误消息
+     * @param error 错误对象或错误字符串（可选）
+     */
+    error(context, message, error) {
+        const ctx = context || this.defaultContext;
+        let fullMessage = ctx ? `[${ctx}] ${message}` : message;
+        if (error) {
+            const errorMessage = error instanceof Error ? error.message : error;
+            fullMessage += `: ${errorMessage}`;
+        }
+        this.logger.error(fullMessage);
+    }
+    /**
+     * 记录用户操作日志（带用户ID和操作结果）
+     * @param operation 操作名称（如 "MC账号绑定"）
+     * @param userId 用户ID（QQ号）
+     * @param success 操作是否成功
+     * @param details 额外详情（可选）
+     */
+    logOperation(operation, userId, success, details = '') {
+        const normalizedQQId = this.normalizeQQId(userId);
+        const status = success ? '成功' : '失败';
+        const message = `QQ(${normalizedQQId}) ${operation} ${status}${details ? ': ' + details : ''}`;
+        if (success) {
+            // 成功的操作，只在debug模式下输出详情
+            // 特殊处理：绑定相关操作强制输出
+            const forceOutput = !this.debugMode && operation.includes('绑定');
+            this.info('操作', message, forceOutput);
+        }
+        else {
+            // 失败的操作总是输出为警告
+            this.warn('操作', message);
+        }
+    }
+    /**
+     * 规范化QQ号格式（移除platform前缀）
+     * @param userId 用户ID（可能包含 platform: 前缀）
+     * @returns 纯QQ号字符串
+     */
+    normalizeQQId(userId) {
+        if (!userId)
+            return '';
+        // 移除可能的 platform: 前缀（如 "onebot:123456" -> "123456"）
+        if (userId.includes(':')) {
+            return userId.split(':').pop() || userId;
+        }
+        return userId;
+    }
+    /**
+     * 创建子日志服务（带固定上下文）
+     * @param context 固定的上下文标签
+     * @returns 新的 LoggerService 实例
+     */
+    createChild(context) {
+        return new LoggerService(this.logger, this.debugMode, context);
+    }
+    /**
+     * 获取原始的 Koishi Logger 实例（用于特殊情况）
+     */
+    getRawLogger() {
+        return this.logger;
+    }
+}
+exports.LoggerService = LoggerService;

package/lib/utils/message-utils.d.ts

@@ -0,0 +1,46 @@
+import { Session } from 'koishi';
+import { LoggerService } from './logger';
+import { BindingSession } from './session-manager';
+/**
+ * 消息工具配置接口
+ */
+export interface MessageUtilsConfig {
+    autoRecallTime: number;
+    recallUserMessage: boolean;
+    autoNicknameGroupId: string;
+    debugMode: boolean;
+}
+/**
+ * 消息工具类
+ * 处理消息发送、撤回和群昵称设置
+ */
+export declare class MessageUtils {
+    private config;
+    private logger;
+    private getBindingSessionFn;
+    /**
+     * 创建消息工具实例
+     * @param config 消息工具配置
+     * @param logger 日志服务
+     * @param getBindingSessionFn 获取绑定会话的函数
+     */
+    constructor(config: MessageUtilsConfig, logger: LoggerService, getBindingSessionFn: (userId: string, channelId: string) => BindingSession | null);
+    /**
+     * 发送消息并处理自动撤回
+     * @param session Koishi Session对象
+     * @param content 消息内容数组
+     * @param options 可选参数
+     */
+    sendMessage(session: Session, content: any[], options?: {
+        isProactiveMessage?: boolean;
+    }): Promise<void>;
+    /**
+     * 自动设置群昵称
+     * @param session Koishi Session对象
+     * @param mcUsername MC用户名
+     * @param buidUsername B站用户名
+     * @param targetUserId 目标用户ID（可选，用于管理员为他人设置）
+     * @param specifiedGroupId 指定的群ID（可选，默认使用配置的群ID）
+     */
+    autoSetGroupNickname(session: Session, mcUsername: string | null, buidUsername: string, targetUserId?: string, specifiedGroupId?: string): Promise<void>;
+}

package/lib/utils/message-utils.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageUtils = void 0;
+const koishi_1 = require("koishi");
+const helpers_1 = require("./helpers");
+/**
+ * 消息工具类
+ * 处理消息发送、撤回和群昵称设置
+ */
+class MessageUtils {
+    config;
+    logger;
+    getBindingSessionFn;
+    /**
+     * 创建消息工具实例
+     * @param config 消息工具配置
+     * @param logger 日志服务
+     * @param getBindingSessionFn 获取绑定会话的函数
+     */
+    constructor(config, logger, getBindingSessionFn) {
+        this.config = config;
+        this.logger = logger;
+        this.getBindingSessionFn = getBindingSessionFn;
+    }
+    /**
+     * 发送消息并处理自动撤回
+     * @param session Koishi Session对象
+     * @param content 消息内容数组
+     * @param options 可选参数
+     */
+    async sendMessage(session, content, options) {
+        try {
+            if (!session) {
+                this.logger.error('消息', 'system操作失败: 无效的会话对象');
+                return;
+            }
+            // 检查是否为群聊消息
+            const isGroupMessage = session.channelId && !session.channelId.startsWith('private:');
+            const normalizedQQId = (0, helpers_1.normalizeQQId)(session.userId);
+            const isProactiveMessage = options?.isProactiveMessage || false;
+            // 处理私聊和群聊的消息格式
+            // 主动消息不引用原消息
+            const promptMessage = session.channelId?.startsWith('private:')
+                ? (isProactiveMessage ? content : [koishi_1.h.quote(session.messageId), ...content])
+                : (isProactiveMessage ? [koishi_1.h.at(normalizedQQId), '\n', ...content] : [koishi_1.h.quote(session.messageId), koishi_1.h.at(normalizedQQId), '\n', ...content]);
+            // 发送消息并获取返回的消息ID
+            const messageResult = await session.send(promptMessage);
+            this.logger.debug('消息', `成功向QQ(${normalizedQQId})发送消息，频道: ${session.channelId}`);
+            // 只在自动撤回时间大于0和存在bot对象时处理撤回
+            if (this.config.autoRecallTime > 0 && session.bot) {
+                // 处理撤回用户消息 - 只在群聊中且开启了用户消息撤回时
+                // 但如果用户在绑定会话中发送聊天消息（不包括指令），不撤回
+                // 主动消息不撤回用户消息
+                const bindingSession = this.getBindingSessionFn(session.userId, session.channelId);
+                const isBindingCommand = session.content && (session.content.trim() === '绑定' ||
+                    session.content.includes('@') && session.content.includes('绑定'));
+                const shouldNotRecallUserMessage = bindingSession && session.content &&
+                    !isBindingCommand && (0, helpers_1.checkIrrelevantInput)(bindingSession.state, session.content.trim());
+                if (this.config.recallUserMessage && isGroupMessage && session.messageId && !shouldNotRecallUserMessage && !isProactiveMessage) {
+                    setTimeout(async () => {
+                        try {
+                            await session.bot.deleteMessage(session.channelId, session.messageId);
+                            this.logger.debug('消息', `成功撤回用户QQ(${normalizedQQId})的指令消息 ${session.messageId}`);
+                        }
+                        catch (userRecallError) {
+                            this.logger.error('消息', `QQ(${normalizedQQId})操作失败: 撤回用户指令消息 ${session.messageId} 失败: ${userRecallError.message}`);
+                        }
+                    }, this.config.autoRecallTime * 1000);
+                    this.logger.debug('消息', `已设置 ${this.config.autoRecallTime} 秒后自动撤回用户QQ(${normalizedQQId})的群聊指令消息 ${session.messageId}`);
+                }
+                else if (shouldNotRecallUserMessage) {
+                    this.logger.debug('消息', `QQ(${normalizedQQId})在绑定会话中发送聊天消息，跳过撤回用户消息`);
+                }
+                else if (isProactiveMessage) {
+                    this.logger.debug('消息', `主动发送的消息，跳过撤回用户消息`);
+                }
+                // 处理撤回机器人消息 - 只在群聊中撤回机器人自己的消息
+                // 检查是否为不应撤回的重要提示消息（只有绑定会话超时提醒）
+                const shouldNotRecall = content.some(element => {
+                    // 检查h.text类型的元素
+                    if (typeof element === 'string') {
+                        return element.includes('绑定会话已超时，请重新开始绑定流程');
+                    }
+                    // 检查可能的对象结构
+                    if (typeof element === 'object' && element && 'toString' in element) {
+                        const text = element.toString();
+                        return text.includes('绑定会话已超时，请重新开始绑定流程');
+                    }
+                    return false;
+                });
+                if (isGroupMessage && messageResult && !shouldNotRecall) {
+                    // 获取消息ID
+                    let messageId;
+                    if (typeof messageResult === 'string') {
+                        messageId = messageResult;
+                    }
+                    else if (Array.isArray(messageResult) && messageResult.length > 0) {
+                        messageId = messageResult[0];
+                    }
+                    else if (messageResult && typeof messageResult === 'object') {
+                        // 尝试提取各种可能的消息ID格式
+                        messageId = messageResult.messageId ||
+                            messageResult.id ||
+                            messageResult.message_id;
+                    }
+                    if (messageId) {
+                        // 设置定时器延迟撤回
+                        setTimeout(async () => {
+                            try {
+                                await session.bot.deleteMessage(session.channelId, messageId);
+                                this.logger.debug('消息', `成功撤回机器人消息 ${messageId}`);
+                            }
+                            catch (recallError) {
+                                this.logger.error('消息', `QQ(${normalizedQQId})操作失败: 撤回机器人消息 ${messageId} 失败: ${recallError.message}`);
+                            }
+                        }, this.config.autoRecallTime * 1000);
+                        this.logger.debug('消息', `已设置 ${this.config.autoRecallTime} 秒后自动撤回机器人消息 ${messageId}`);
+                    }
+                    else {
+                        this.logger.warn('消息', `无法获取消息ID，自动撤回功能无法生效`);
+                    }
+                }
+                else {
+                    this.logger.debug('消息', `检测到私聊消息，不撤回机器人回复`);
+                }
+            }
+        }
+        catch (error) {
+            const normalizedUserId = (0, helpers_1.normalizeQQId)(session.userId);
+            this.logger.error('消息', `QQ(${normalizedUserId})操作失败: 向QQ(${normalizedUserId})发送消息失败: ${error.message}`);
+        }
+    }
+    /**
+     * 自动设置群昵称
+     * @param session Koishi Session对象
+     * @param mcUsername MC用户名
+     * @param buidUsername B站用户名
+     * @param targetUserId 目标用户ID（可选，用于管理员为他人设置）
+     * @param specifiedGroupId 指定的群ID（可选，默认使用配置的群ID）
+     */
+    async autoSetGroupNickname(session, mcUsername, buidUsername, targetUserId, specifiedGroupId) {
+        try {
+            // 如果指定了目标用户ID，使用目标用户ID，否则使用session的用户ID
+            const actualUserId = targetUserId || session.userId;
+            const normalizedUserId = (0, helpers_1.normalizeQQId)(actualUserId);
+            // 根据MC绑定状态设置不同的格式（临时用户名视为未绑定）
+            const mcInfo = (mcUsername && !mcUsername.startsWith('_temp_')) ? mcUsername : "未绑定";
+            const newNickname = `${buidUsername}（ID:${mcInfo}）`;
+            // 使用指定的群ID，如果没有指定则使用配置的默认群ID
+            const targetGroupId = specifiedGroupId || this.config.autoNicknameGroupId;
+            this.logger.debug('群昵称设置', `开始处理QQ(${normalizedUserId})的群昵称设置，目标群: ${targetGroupId}`);
+            this.logger.debug('群昵称设置', `期望昵称: "${newNickname}"`);
+            if (session.bot.internal && targetGroupId) {
+                // 使用规范化的QQ号调用OneBot API
+                this.logger.debug('群昵称设置', `使用用户ID: ${normalizedUserId}`);
+                // 先获取当前群昵称进行比对
+                try {
+                    this.logger.debug('群昵称设置', `正在获取QQ(${normalizedUserId})在群${targetGroupId}的当前昵称...`);
+                    const currentGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
+                    const currentNickname = currentGroupInfo.card || currentGroupInfo.nickname || '';
+                    this.logger.debug('群昵称设置', `当前昵称: "${currentNickname}"`);
+                    // 如果当前昵称和目标昵称一致，跳过修改
+                    if (currentNickname === newNickname) {
+                        this.logger.info('群昵称设置', `QQ(${normalizedUserId})群昵称已经是"${newNickname}"，跳过修改`);
+                        return;
+                    }
+                    // 昵称不一致，执行修改
+                    this.logger.debug('群昵称设置', `昵称不一致，正在修改群昵称...`);
+                    await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, newNickname);
+                    this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称从"${currentNickname}"修改为"${newNickname}"`, true);
+                    // 验证设置是否生效 - 再次获取群昵称确认
+                    try {
+                        await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
+                        const verifyGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
+                        const verifyNickname = verifyGroupInfo.card || verifyGroupInfo.nickname || '';
+                        if (verifyNickname === newNickname) {
+                            this.logger.info('群昵称设置', `✅ 验证成功，群昵称已生效: "${verifyNickname}"`, true);
+                        }
+                        else {
+                            this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${newNickname}"，实际"${verifyNickname}"，可能是权限不足或API延迟`);
+                        }
+                    }
+                    catch (verifyError) {
+                        this.logger.warn('群昵称设置', `无法验证群昵称设置结果: ${verifyError.message}`);
+                    }
+                }
+                catch (getInfoError) {
+                    // 如果获取当前昵称失败，直接尝试设置新昵称
+                    this.logger.warn('群昵称设置', `获取QQ(${normalizedUserId})当前群昵称失败: ${getInfoError.message}`);
+                    this.logger.warn('群昵称设置', `错误详情: ${JSON.stringify(getInfoError)}`);
+                    this.logger.debug('群昵称设置', `将直接尝试设置新昵称...`);
+                    try {
+                        await session.bot.internal.setGroupCard(targetGroupId, normalizedUserId, newNickname);
+                        this.logger.info('群昵称设置', `成功在群${targetGroupId}中将QQ(${normalizedUserId})群昵称设置为: ${newNickname}`, true);
+                        // 验证设置是否生效
+                        try {
+                            await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
+                            const verifyGroupInfo = await session.bot.internal.getGroupMemberInfo(targetGroupId, normalizedUserId);
+                            const verifyNickname = verifyGroupInfo.card || verifyGroupInfo.nickname || '';
+                            if (verifyNickname === newNickname) {
+                                this.logger.info('群昵称设置', `✅ 验证成功，群昵称已生效: "${verifyNickname}"`, true);
+                            }
+                            else {
+                                this.logger.warn('群昵称设置', `⚠️ 验证失败，期望"${newNickname}"，实际"${verifyNickname}"，可能是权限不足`);
+                                this.logger.warn('群昵称设置', `建议检查: 1.机器人是否为群管理员 2.群设置是否允许管理员修改昵称 3.OneBot实现是否支持该功能`);
+                            }
+                        }
+                        catch (verifyError) {
+                            this.logger.warn('群昵称设置', `无法验证群昵称设置结果: ${verifyError.message}`);
+                        }
+                    }
+                    catch (setCardError) {
+                        this.logger.error('群昵称设置', `设置群昵称失败: ${setCardError.message}`);
+                        this.logger.error('群昵称设置', `错误详情: ${JSON.stringify(setCardError)}`);
+                        throw setCardError;
+                    }
+                }
+            }
+            else if (!session.bot.internal) {
+                this.logger.debug('群昵称设置', `QQ(${normalizedUserId})bot不支持OneBot内部API，跳过自动群昵称设置`);
+            }
+            else if (!targetGroupId) {
+                this.logger.debug('群昵称设置', `QQ(${normalizedUserId})未配置自动群昵称设置目标群，跳过群昵称设置`);
+            }
+        }
+        catch (error) {
+            const actualUserId = targetUserId || session.userId;
+            const normalizedUserId = (0, helpers_1.normalizeQQId)(actualUserId);
+            this.logger.error('群昵称设置', `QQ(${normalizedUserId})自动群昵称设置失败: ${error.message}`);
+            this.logger.error('群昵称设置', `完整错误信息: ${JSON.stringify(error)}`);
+        }
+    }
+}
+exports.MessageUtils = MessageUtils;

package/lib/utils/rate-limiter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 简单的请求限流器
+ * 用于控制特定时间窗口内的请求频率
+ */
+export declare class RateLimiter {
+    private requestTimes;
+    private limit;
+    private timeWindow;
+    /**
+     * 创建限流器实例
+     * @param limit 时间窗口内允许的最大请求数
+     * @param timeWindowMs 时间窗口大小（毫秒）
+     */
+    constructor(limit?: number, timeWindowMs?: number);
+    /**
+     * 检查是否允许新请求
+     * @param key 请求的唯一标识（如用户ID）
+     * @returns 是否允许请求
+     */
+    canMakeRequest(key: string): boolean;
+    /**
+     * 记录新请求
+     * @param key 请求的唯一标识（如用户ID）
+     */
+    recordRequest(key: string): void;
+}

package/lib/utils/rate-limiter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimiter = void 0;
+/**
+ * 简单的请求限流器
+ * 用于控制特定时间窗口内的请求频率
+ */
+class RateLimiter {
+    requestTimes = {};
+    limit;
+    timeWindow;
+    /**
+     * 创建限流器实例
+     * @param limit 时间窗口内允许的最大请求数
+     * @param timeWindowMs 时间窗口大小（毫秒）
+     */
+    constructor(limit = 10, timeWindowMs = 3000) {
+        this.limit = limit;
+        this.timeWindow = timeWindowMs;
+    }
+    /**
+     * 检查是否允许新请求
+     * @param key 请求的唯一标识（如用户ID）
+     * @returns 是否允许请求
+     */
+    canMakeRequest(key) {
+        const now = Date.now();
+        if (!this.requestTimes[key]) {
+            this.requestTimes[key] = [];
+        }
+        // 清理过期请求时间
+        this.requestTimes[key] = this.requestTimes[key].filter(time => now - time < this.timeWindow);
+        // 检查是否超过限制
+        return this.requestTimes[key].length < this.limit;
+    }
+    /**
+     * 记录新请求
+     * @param key 请求的唯一标识（如用户ID）
+     */
+    recordRequest(key) {
+        if (!this.requestTimes[key]) {
+            this.requestTimes[key] = [];
+        }
+        this.requestTimes[key].push(Date.now());
+    }
+}
+exports.RateLimiter = RateLimiter;

package/lib/utils/session-manager.d.ts

@@ -0,0 +1,70 @@
+import { Context } from 'koishi';
+import { LoggerService } from './logger';
+/**
+ * 交互式绑定会话状态接口
+ */
+export interface BindingSession {
+    userId: string;
+    channelId: string;
+    state: 'waiting_mc_username' | 'waiting_buid';
+    startTime: number;
+    timeout: NodeJS.Timeout;
+    mcUsername?: string;
+    mcUuid?: string;
+    invalidInputCount?: number;
+}
+/**
+ * 绑定会话管理器
+ * 管理交互式绑定流程的会话状态
+ */
+export declare class SessionManager {
+    private sessions;
+    private sessionTimeout;
+    private ctx;
+    private logger;
+    /**
+     * 创建会话管理器实例
+     * @param ctx Koishi Context
+     * @param logger 日志服务
+     * @param sessionTimeout 会话超时时间（毫秒）
+     */
+    constructor(ctx: Context, logger: LoggerService, sessionTimeout?: number);
+    /**
+     * 生成会话键
+     */
+    private getSessionKey;
+    /**
+     * 创建新的绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     */
+    createSession(userId: string, channelId: string): void;
+    /**
+     * 获取绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     * @returns 绑定会话或null
+     */
+    getSession(userId: string, channelId: string): BindingSession | null;
+    /**
+     * 更新绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     * @param updates 更新的字段
+     */
+    updateSession(userId: string, channelId: string, updates: Partial<BindingSession>): void;
+    /**
+     * 移除绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     */
+    removeSession(userId: string, channelId: string): void;
+    /**
+     * 获取当前活跃会话数量
+     */
+    getActiveSessionCount(): number;
+    /**
+     * 清除所有会话（通常在插件卸载时调用）
+     */
+    clearAllSessions(): void;
+}

package/lib/utils/session-manager.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const koishi_1 = require("koishi");
+const helpers_1 = require("./helpers");
+/**
+ * 绑定会话管理器
+ * 管理交互式绑定流程的会话状态
+ */
+class SessionManager {
+    sessions = new Map();
+    sessionTimeout;
+    ctx;
+    logger;
+    /**
+     * 创建会话管理器实例
+     * @param ctx Koishi Context
+     * @param logger 日志服务
+     * @param sessionTimeout 会话超时时间（毫秒）
+     */
+    constructor(ctx, logger, sessionTimeout = 3 * 60 * 1000) {
+        this.ctx = ctx;
+        this.logger = logger;
+        this.sessionTimeout = sessionTimeout;
+    }
+    /**
+     * 生成会话键
+     */
+    getSessionKey(userId, channelId) {
+        return `${(0, helpers_1.normalizeQQId)(userId)}_${channelId}`;
+    }
+    /**
+     * 创建新的绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     */
+    createSession(userId, channelId) {
+        const sessionKey = this.getSessionKey(userId, channelId);
+        // 如果已有会话，先清理
+        const existingSession = this.sessions.get(sessionKey);
+        if (existingSession) {
+            clearTimeout(existingSession.timeout);
+            this.sessions.delete(sessionKey);
+        }
+        // 创建超时定时器
+        const timeout = setTimeout(() => {
+            this.sessions.delete(sessionKey);
+            // 发送超时消息，@用户
+            const normalizedUser = (0, helpers_1.normalizeQQId)(userId);
+            this.ctx.bots.forEach(bot => {
+                bot.sendMessage(channelId, [koishi_1.h.at(normalizedUser), koishi_1.h.text(' 绑定会话已超时，请重新开始绑定流程\n\n⚠️ 温馨提醒：若在管理员多次提醒后仍不配合绑定账号信息，将按群规进行相应处理。')]).catch(() => { });
+            });
+            this.logger.info('交互绑定', `QQ(${normalizedUser})的绑定会话因超时被清理`, true);
+        }, this.sessionTimeout);
+        // 创建新会话
+        const session = {
+            userId: (0, helpers_1.normalizeQQId)(userId),
+            channelId,
+            state: 'waiting_buid',
+            startTime: Date.now(),
+            timeout
+        };
+        this.sessions.set(sessionKey, session);
+        this.logger.info('交互绑定', `为QQ(${(0, helpers_1.normalizeQQId)(userId)})创建了新的绑定会话`, true);
+    }
+    /**
+     * 获取绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     * @returns 绑定会话或null
+     */
+    getSession(userId, channelId) {
+        const sessionKey = this.getSessionKey(userId, channelId);
+        return this.sessions.get(sessionKey) || null;
+    }
+    /**
+     * 更新绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     * @param updates 更新的字段
+     */
+    updateSession(userId, channelId, updates) {
+        const sessionKey = this.getSessionKey(userId, channelId);
+        const session = this.sessions.get(sessionKey);
+        if (session) {
+            Object.assign(session, updates);
+        }
+    }
+    /**
+     * 移除绑定会话
+     * @param userId 用户ID
+     * @param channelId 频道ID
+     */
+    removeSession(userId, channelId) {
+        const sessionKey = this.getSessionKey(userId, channelId);
+        const session = this.sessions.get(sessionKey);
+        if (session) {
+            clearTimeout(session.timeout);
+            this.sessions.delete(sessionKey);
+            this.logger.info('交互绑定', `移除了QQ(${(0, helpers_1.normalizeQQId)(userId)})的绑定会话`, true);
+        }
+    }
+    /**
+     * 获取当前活跃会话数量
+     */
+    getActiveSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * 清除所有会话（通常在插件卸载时调用）
+     */
+    clearAllSessions() {
+        for (const [, session] of this.sessions.entries()) {
+            clearTimeout(session.timeout);
+        }
+        this.sessions.clear();
+        this.logger.info('交互绑定', '已清除所有绑定会话', true);
+    }
+}
+exports.SessionManager = SessionManager;