koishi-plugin-maibot 1.6.14 → 1.7.10-alpha

package/lib/index.js

@@ -332,11 +332,112 @@ async function extractQRCodeFromSession(session, ctx) {
     }
     return null;
 }
+/**
+ * 交互式获取二维码文本（qr_text）
+ * 如果binding存在且包含qrCode，优先使用；否则提示用户输入
+ * 如果API调用失败，会尝试重新绑定
+ */
+async function getQrText(session, ctx, api, binding, config, timeout = 60000, promptMessage) {
+    const logger = ctx.logger('maibot');
+    // 如果绑定存在且有qrCode，先验证是否有效
+    if (binding && binding.qrCode) {
+        // 验证qrCode是否仍然有效（可选，如果验证失败再提示重新输入）
+        try {
+            const preview = await api.getPreview(config.machineInfo.clientId, binding.qrCode);
+            if (preview.UserID !== -1 && (typeof preview.UserID !== 'string' || preview.UserID !== '-1')) {
+                // qrCode有效，直接返回
+                return { qrText: binding.qrCode };
+            }
+            // qrCode无效，需要重新绑定
+            logger.warn(`用户 ${binding.userId} 的qrCode已失效，需要重新绑定`);
+            return { qrText: '', error: '二维码已失效', needRebind: true };
+        }
+        catch (error) {
+            // 验证失败，可能需要重新绑定，但先尝试使用现有qrCode
+            logger.warn(`验证qrCode失败，将使用现有qrCode: ${error}`);
+            return { qrText: binding.qrCode };
+        }
+    }
+    // 否则提示用户输入
+    const actualTimeout = timeout;
+    const message = promptMessage || `请在${actualTimeout / 1000}秒内直接发送SGID（长按玩家二维码识别后发送）`;
+    try {
+        await session.send(message);
+        logger.info(`开始等待用户 ${session.userId} 输入SGID，超时时间: ${actualTimeout}ms`);
+        const promptText = await session.prompt(actualTimeout);
+        if (!promptText || !promptText.trim()) {
+            await session.send(`❌ 输入超时（${actualTimeout / 1000}秒）`);
+            return { qrText: '', error: '超时未收到响应' };
+        }
+        const trimmed = promptText.trim();
+        logger.debug(`收到用户输入: ${trimmed.substring(0, 50)}`);
+        // 检查是否为SGID格式
+        if (!trimmed.startsWith('SGWCMAID')) {
+            await session.send('⚠️ 未识别到有效的SGID格式，请发送SGID文本（SGWCMAID开头）');
+            return { qrText: '', error: '无效的二维码格式，必须以 SGWCMAID 开头' };
+        }
+        // 验证二维码格式
+        if (trimmed.length < 48 || trimmed.length > 128) {
+            await session.send('❌ SGID长度错误，应在48-128字符之间');
+            return { qrText: '', error: '二维码长度错误，应在48-128字符之间' };
+        }
+        logger.info(`✅ 接收到SGID: ${trimmed.substring(0, 20)}...`);
+        await session.send('⏳ 正在处理SGID，请稍候...');
+        // 验证qrCode是否有效
+        try {
+            const preview = await api.getPreview(config.machineInfo.clientId, trimmed);
+            if (preview.UserID === -1 || (typeof preview.UserID === 'string' && preview.UserID === '-1')) {
+                await session.send('❌ 无效或过期的二维码，请重新发送');
+                return { qrText: '', error: '无效或过期的二维码' };
+            }
+            // 如果binding存在，更新数据库中的qrCode
+            if (binding) {
+                await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
+                    qrCode: trimmed,
+                });
+                logger.info(`已更新用户 ${binding.userId} 的qrCode`);
+            }
+            return { qrText: trimmed };
+        }
+        catch (error) {
+            logger.error('验证qrCode失败:', error);
+            await session.send(`❌ 验证二维码失败：${error?.message || '未知错误'}`);
+            return { qrText: '', error: `验证二维码失败：${error?.message || '未知错误'}` };
+        }
+    }
+    catch (error) {
+        logger.error(`等待用户输入二维码失败: ${error?.message}`, error);
+        if (error.message?.includes('超时') || error.message?.includes('timeout') || error.message?.includes('未收到响应')) {
+            await session.send(`❌ 输入超时（${actualTimeout / 1000}秒）`);
+            return { qrText: '', error: '超时未收到响应' };
+        }
+        return { qrText: '', error: error?.message || '未知错误' };
+    }
+}
+/**
+ * 处理API调用失败，如果需要重新绑定则进入重新绑定流程
+ */
+async function handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout) {
+    const logger = ctx.logger('maibot');
+    // 检查错误是否表示需要重新绑定（例如UserID为-1，或qr_text相关错误）
+    const needRebind = error?.response?.data?.UserID === -1 ||
+        error?.response?.data?.UserID === '-1' ||
+        error?.message?.includes('二维码') ||
+        error?.message?.includes('qr_text') ||
+        error?.message?.includes('无效') ||
+        error?.message?.includes('过期');
+    if (needRebind && binding) {
+        logger.info(`检测到需要重新绑定，用户: ${binding.userId}`);
+        const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+        return { success: false, rebindResult };
+    }
+    return { success: false, error: error?.message || '未知错误' };
+}
 /**
  * 提示用户重新绑定二维码
  * 只支持用户输入SGID文本
  */
-async function promptForRebind(session, ctx, api, binding, timeout = 60000) {
+async function promptForRebind(session, ctx, api, binding, config, timeout = 60000) {
     const actualTimeout = timeout;
     const logger = ctx.logger('maibot');
     // 发送提示消息
@@ -378,29 +479,36 @@ async function promptForRebind(session, ctx, api, binding, timeout = 60000) {
             await session.send('❌ 识别失败：SGID长度错误，应在48-128字符之间');
             return { success: false, error: '二维码长度错误，应在48-128字符之间', messageId: promptMessageId };
         }
-        // 调用API获取用户ID
-        const result = await api.qr2userid(qrCode);
-        if (!result.QRStatus) {
-            const errorMsg = result.UserID === 'MTI1MTEy' ? '无效或过期的二维码' : result.UserID;
-            await session.send(`❌ 绑定失败：无法从二维码获取用户ID\n错误信息: ${errorMsg}`);
+        // 使用新API获取用户信息（需要client_id）
+        // 注意：这里需要从配置中获取client_id，但为了兼容性，我们先尝试使用getPreview
+        // 如果失败，可能需要提示用户输入client_id或从配置中获取
+        const machineInfo = config.machineInfo;
+        let previewResult;
+        try {
+            previewResult = await api.getPreview(machineInfo.clientId, qrCode);
+        }
+        catch (error) {
+            logger.error('获取用户预览信息失败:', error);
+            await session.send(`❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`);
             return {
                 success: false,
-                error: `绑定失败：无法从二维码获取用户ID\n错误信息: ${errorMsg}`,
+                error: `绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`,
                 messageId: promptMessageId
             };
         }
-        const maiUid = result.UserID;
-        // 获取用户详细信息
-        let userName;
-        let rating;
-        try {
-            const preview = await api.preview(maiUid);
-            userName = preview.UserName;
-            rating = preview.Rating;
-        }
-        catch (error) {
-            logger.warn('获取用户预览信息失败:', error);
+        // 检查是否获取成功
+        if (previewResult.UserID === -1 || (typeof previewResult.UserID === 'string' && previewResult.UserID === '-1')) {
+            await session.send(`❌ 绑定失败：无效或过期的二维码`);
+            return {
+                success: false,
+                error: '绑定失败：无效或过期的二维码',
+                messageId: promptMessageId
+            };
         }
+        // UserID在新API中是加密的字符串
+        const maiUid = String(previewResult.UserID);
+        const userName = previewResult.UserName;
+        const rating = previewResult.Rating ? String(previewResult.Rating) : undefined;
         // 更新数据库中的绑定
         await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
             maiUid,
@@ -638,7 +746,7 @@ function apply(ctx, config) {
                         ? `❌ 任务失败：${detail.error}`
                         : '✅ 任务已完成';
                     const finishTime = detail.alive_task_end_time
-                        ? `\n完成时间: ${new Date(parseInt(detail.alive_task_end_time) * 1000).toLocaleString('zh-CN')}`
+                        ? `\n完成时间: ${new Date((typeof detail.alive_task_end_time === 'number' ? detail.alive_task_end_time : parseInt(String(detail.alive_task_end_time))) * 1000).toLocaleString('zh-CN')}`
                         : '';
                     await bot.sendMessage(channelId, `${mention} 水鱼B50任务 ${taskId} 状态更新\n${statusText}${finishTime}`, guildId);
                     return;
@@ -693,7 +801,7 @@ function apply(ctx, config) {
                         ? `❌ 任务失败：${detail.error}`
                         : '✅ 任务已完成';
                     const finishTime = detail.alive_task_end_time
-                        ? `\n完成时间: ${new Date(parseInt(detail.alive_task_end_time) * 1000).toLocaleString('zh-CN')}`
+                        ? `\n完成时间: ${new Date((typeof detail.alive_task_end_time === 'number' ? detail.alive_task_end_time : parseInt(String(detail.alive_task_end_time))) * 1000).toLocaleString('zh-CN')}`
                         : '';
                     await bot.sendMessage(channelId, `${mention} 落雪B50任务 ${taskId} 状态更新\n${statusText}${finishTime}`, guildId);
                     return;
@@ -859,24 +967,24 @@ function apply(ctx, config) {
             if (qrCode.length < 48 || qrCode.length > 128) {
                 return '❌ 二维码长度错误，应在48-128字符之间';
             }
-            // 调用API获取用户ID
-            const result = await api.qr2userid(qrCode);
-            if (!result.QRStatus) {
-                return `❌ 绑定失败：无法从二维码获取用户ID\n错误信息: ${result.UserID === 'MTI1MTEy' ? '无效或过期的二维码' : result.UserID}`;
-            }
-            const maiUid = result.UserID;
-            // 获取用户详细信息（可选）
-            let userName;
-            let rating;
+            // 使用新API获取用户信息（需要client_id）
+            const machineInfo = config.machineInfo;
+            let previewResult;
             try {
-                const preview = await api.preview(maiUid);
-                userName = preview.UserName;
-                rating = preview.Rating;
+                previewResult = await api.getPreview(machineInfo.clientId, qrCode);
             }
             catch (error) {
-                // 如果获取预览失败，不影响绑定
-                ctx.logger('maibot').warn('获取用户预览信息失败:', error);
+                ctx.logger('maibot').error('获取用户预览信息失败:', error);
+                return `❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`;
+            }
+            // 检查是否获取成功
+            if (previewResult.UserID === -1 || (typeof previewResult.UserID === 'string' && previewResult.UserID === '-1')) {
+                return `❌ 绑定失败：无效或过期的二维码`;
             }
+            // UserID在新API中是加密的字符串
+            const maiUid = String(previewResult.UserID);
+            const userName = previewResult.UserName;
+            const rating = previewResult.Rating ? String(previewResult.Rating) : undefined;
             // 存储到数据库
             await ctx.database.create('maibot_bindings', {
                 userId,
@@ -956,49 +1064,60 @@ function apply(ctx, config) {
                 `🚨 /maialert查看账号提醒状态\n`;
             // 尝试获取最新状态并更新数据库
             try {
-                const preview = await api.preview(binding.maiUid);
-                // 更新数据库中的用户名和Rating
-                await ctx.database.set('maibot_bindings', { userId }, {
-                    userName: preview.UserName,
-                    rating: preview.Rating,
-                });
-                // 格式化版本信息
-                let versionInfo = '';
-                if (preview.RomVersion && preview.DataVersion) {
-                    // 机台版本：取前两个数字，如 1.52.00 -> 1.52
-                    const romVersionMatch = preview.RomVersion.match(/^(\d+\.\d+)/);
-                    const romVersion = romVersionMatch ? romVersionMatch[1] : preview.RomVersion;
-                    // 数据版本：取前两个数字 + 最后两个数字转换为字母，如 1.50.09 -> 1.50 - I
-                    const dataVersionPrefixMatch = preview.DataVersion.match(/^(\d+\.\d+)/);
-                    const dataVersionPrefix = dataVersionPrefixMatch ? dataVersionPrefixMatch[1] : preview.DataVersion;
-                    // 从版本号末尾提取最后两位数字，如 "1.50.01" -> "01", "1.50.09" -> "09"
-                    // 匹配最后一个点后的数字（确保只匹配版本号末尾）
-                    let dataVersionLetter = '';
-                    // 匹配最后一个点后的1-2位数字
-                    const dataVersionMatch = preview.DataVersion.match(/\.(\d{1,2})$/);
-                    if (dataVersionMatch) {
-                        // 提取数字字符串，如 "09" 或 "9"
-                        const digitsStr = dataVersionMatch[1];
-                        // 转换为数字，如 "09" -> 9, "9" -> 9
-                        const versionNumber = parseInt(digitsStr, 10);
-                        // 验证转换是否正确
-                        if (!isNaN(versionNumber) && versionNumber >= 1) {
-                            // 01 -> A, 02 -> B, ..., 09 -> I, 10 -> J, ..., 26 -> Z
-                            // 使用模运算确保在 A-Z 范围内循环（27 -> A, 28 -> B, ...）
-                            const letterIndex = ((versionNumber - 1) % 26) + 1;
-                            // 转换为大写字母：A=65, B=66, ..., Z=90
-                            dataVersionLetter = String.fromCharCode(64 + letterIndex).toUpperCase();
+                // 使用新API获取用户信息（需要qr_text）
+                if (!binding.qrCode) {
+                    logger.warn(`用户 ${userId} 没有qrCode，无法更新用户信息`);
+                }
+                else {
+                    try {
+                        const preview = await api.getPreview(machineInfo.clientId, binding.qrCode);
+                        // 更新数据库中的用户名和Rating
+                        await ctx.database.set('maibot_bindings', { userId }, {
+                            userName: preview.UserName,
+                            rating: preview.Rating ? String(preview.Rating) : undefined,
+                        });
+                        // 格式化版本信息
+                        let versionInfo = '';
+                        if (preview.RomVersion && preview.DataVersion) {
+                            // 机台版本：取前两个数字，如 1.52.00 -> 1.52
+                            const romVersionMatch = preview.RomVersion.match(/^(\d+\.\d+)/);
+                            const romVersion = romVersionMatch ? romVersionMatch[1] : preview.RomVersion;
+                            // 数据版本：取前两个数字 + 最后两个数字转换为字母，如 1.50.09 -> 1.50 - I
+                            const dataVersionPrefixMatch = preview.DataVersion.match(/^(\d+\.\d+)/);
+                            const dataVersionPrefix = dataVersionPrefixMatch ? dataVersionPrefixMatch[1] : preview.DataVersion;
+                            // 从版本号末尾提取最后两位数字，如 "1.50.01" -> "01", "1.50.09" -> "09"
+                            // 匹配最后一个点后的数字（确保只匹配版本号末尾）
+                            let dataVersionLetter = '';
+                            // 匹配最后一个点后的1-2位数字
+                            const dataVersionMatch = preview.DataVersion.match(/\.(\d{1,2})$/);
+                            if (dataVersionMatch) {
+                                // 提取数字字符串，如 "09" 或 "9"
+                                const digitsStr = dataVersionMatch[1];
+                                // 转换为数字，如 "09" -> 9, "9" -> 9
+                                const versionNumber = parseInt(digitsStr, 10);
+                                // 验证转换是否正确
+                                if (!isNaN(versionNumber) && versionNumber >= 1) {
+                                    // 01 -> A, 02 -> B, ..., 09 -> I, 10 -> J, ..., 26 -> Z
+                                    // 使用模运算确保在 A-Z 范围内循环（27 -> A, 28 -> B, ...）
+                                    const letterIndex = ((versionNumber - 1) % 26) + 1;
+                                    // 转换为大写字母：A=65, B=66, ..., Z=90
+                                    dataVersionLetter = String.fromCharCode(64 + letterIndex).toUpperCase();
+                                }
+                            }
+                            versionInfo = `机台版本: ${romVersion}\n` +
+                                `数据版本: ${dataVersionPrefix} - ${dataVersionLetter}\n`;
                         }
+                        statusInfo += `\n📊 账号信息：\n` +
+                            `用户名: ${preview.UserName || '未知'}\n` +
+                            `Rating: ${preview.Rating || '未知'}\n` +
+                            (versionInfo ? versionInfo : '') +
+                            `登录状态: ${preview.IsLogin === true ? '已登录' : '未登录'}\n` +
+                            `封禁状态: ${preview.BanState === 0 ? '正常' : '已封禁'}\n`;
+                    }
+                    catch (error) {
+                        logger.warn('获取用户预览信息失败:', error);
                     }
-                    versionInfo = `机台版本: ${romVersion}\n` +
-                        `数据版本: ${dataVersionPrefix} - ${dataVersionLetter}\n`;
                 }
-                statusInfo += `\n📊 账号信息：\n` +
-                    `用户名: ${preview.UserName}\n` +
-                    `Rating: ${preview.Rating}\n` +
-                    (versionInfo ? versionInfo : '') +
-                    `登录状态: ${preview.IsLogin}\n` +
-                    `封禁状态: ${preview.BanState}\n`;
             }
             catch (error) {
                 // 如果获取失败，使用缓存的信息
@@ -1045,134 +1164,8 @@ function apply(ctx, config) {
                 }
             }
             // 显示票券信息
-            try {
-                const chargeInfo = await api.getCharge(binding.maiUid, turnstileToken);
-                // 检查校验失败
-                if (chargeInfo.UserID === -2) {
-                    statusInfo += `\n\n🎫 票券情况: 获取失败（Turnstile校验失败）`;
-                }
-                else if (!chargeInfo.ChargeStatus) {
-                    // 获取失败
-                    statusInfo += `\n\n🎫 票券情况: 获取失败`;
-                }
-                else {
-                    const now = new Date();
-                    const showExpired = options?.expired || false; // 是否显示过期票券
-                    // 被发的功能票（发票）：只显示 id: 2, 3, 4, 5, 6
-                    const issuedTicketIds = [2, 3, 4, 5, 6];
-                    const issuedCharges = (chargeInfo.userChargeList || []).filter(charge => issuedTicketIds.includes(charge.chargeId));
-                    // 用户购买的功能票：只显示 id: 10005, 10105, 10205, 30001, 0, 11001, 30002, 30003
-                    const purchasedTicketIds = [10005, 10105, 10205, 30001, 0, 11001, 30002, 30003];
-                    const purchasedCharges = (chargeInfo.userFreeChargeList || []).filter(charge => purchasedTicketIds.includes(charge.chargeId));
-                    // 计算发票库存（包括过期的）
-                    const allIssuedStock = issuedCharges
-                        .filter(charge => charge.stock > 0)
-                        .reduce((sum, charge) => sum + charge.stock, 0);
-                    // 计算发票过期库存
-                    const expiredIssuedStock = issuedCharges
-                        .filter(charge => {
-                        if (charge.stock > 0 && charge.validDate) {
-                            const validDate = new Date(charge.validDate);
-                            return validDate.getFullYear() >= 2000 && validDate < now;
-                        }
-                        return false;
-                    })
-                        .reduce((sum, charge) => sum + charge.stock, 0);
-                    // 计算购买库存
-                    const purchasedStock = purchasedCharges
-                        .filter(charge => charge.stock > 0)
-                        .reduce((sum, charge) => sum + charge.stock, 0);
-                    // 总票数
-                    const totalStock = allIssuedStock + purchasedStock;
-                    // 格式化总票数显示
-                    let totalStockText = `${totalStock}（发票：${allIssuedStock}`;
-                    if (showExpired && expiredIssuedStock > 0) {
-                        totalStockText += `（包含过期：${expiredIssuedStock}）`;
-                    }
-                    totalStockText += ` + 购买：${purchasedStock}）`;
-                    // 过滤显示的被发功能票
-                    let displayIssuedCharges;
-                    if (showExpired) {
-                        displayIssuedCharges = issuedCharges.filter(charge => charge.stock > 0);
-                    }
-                    else {
-                        displayIssuedCharges = issuedCharges.filter(charge => {
-                            if (charge.stock <= 0)
-                                return false;
-                            if (charge.validDate) {
-                                const validDate = new Date(charge.validDate);
-                                return validDate.getFullYear() >= 2000 && validDate >= now;
-                            }
-                            return true;
-                        });
-                    }
-                    // 过滤显示的购买功能票
-                    const displayPurchasedCharges = purchasedCharges.filter(charge => charge.stock > 0);
-                    // 显示票券信息
-                    if (displayIssuedCharges.length > 0 || displayPurchasedCharges.length > 0) {
-                        statusInfo += `\n\n🎫 票券情况（总票数: ${totalStockText}）${showExpired ? '（包含过期）' : ''}：\n`;
-                        // 显示被发的功能票（发票）
-                        if (displayIssuedCharges.length > 0) {
-                            statusInfo += `\n📤 被发的功能票（发票）：\n`;
-                            for (const charge of displayIssuedCharges) {
-                                const ticketName = getTicketName(charge.chargeId);
-                                // 检查购买日期是否异常（小于2000年）
-                                let purchaseDate;
-                                if (charge.purchaseDate) {
-                                    const purchaseDateObj = new Date(charge.purchaseDate);
-                                    if (purchaseDateObj.getFullYear() < 2000) {
-                                        purchaseDate = '19**/*/* **:**:00 [Hacked | 异常登录]';
-                                    }
-                                    else {
-                                        purchaseDate = purchaseDateObj.toLocaleString('zh-CN');
-                                    }
-                                }
-                                else {
-                                    purchaseDate = '未知';
-                                }
-                                // 检查有效期日期是否异常（小于2000年）
-                                let validDate;
-                                if (charge.validDate) {
-                                    const validDateObj = new Date(charge.validDate);
-                                    if (validDateObj.getFullYear() < 2000) {
-                                        validDate = '19**/*/* **:**:00 [Hacked | 异常登录]';
-                                    }
-                                    else {
-                                        validDate = validDateObj.toLocaleString('zh-CN');
-                                    }
-                                }
-                                else {
-                                    validDate = '未知';
-                                }
-                                // 检查是否过期（只检查正常日期）
-                                const isExpired = charge.validDate && new Date(charge.validDate).getFullYear() >= 2000
-                                    ? new Date(charge.validDate) < now
-                                    : false;
-                                statusInfo += `\n${ticketName} (ID: ${charge.chargeId})${isExpired ? ' [已过期]' : ''}\n`;
-                                statusInfo += `  库存: ${charge.stock}\n`;
-                                statusInfo += `  购买日期: ${purchaseDate}\n`;
-                                statusInfo += `  有效期至: ${validDate}\n`;
-                            }
-                        }
-                        // 显示用户购买的功能票
-                        if (displayPurchasedCharges.length > 0) {
-                            statusInfo += `\n🛒 用户购买的功能票：\n`;
-                            for (const charge of displayPurchasedCharges) {
-                                const ticketName = getTicketName(charge.chargeId);
-                                statusInfo += `\n${ticketName} (ID: ${charge.chargeId})\n`;
-                                statusInfo += `  库存: ${charge.stock}\n`;
-                            }
-                        }
-                    }
-                    else {
-                        statusInfo += `\n\n🎫 票券情况: 总票数 ${totalStockText}`;
-                    }
-                }
-            }
-            catch (error) {
-                logger.warn('获取票券信息失败:', error);
-                statusInfo += `\n\n🎫 票券情况: 获取失败，请检查API服务`;
-            }
+            // @deprecated getCharge功能已在新API中移除，已注释
+            statusInfo += `\n\n🎫 票券情况: 此功能已在新API中移除`;
             return statusInfo;
         }
         catch (error) {
@@ -1186,150 +1179,193 @@ function apply(ctx, config) {
     /**
      * 锁定账号（登录保持）
      * 用法: /mai锁定
+     * @deprecated 锁定功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai锁定 [targetUserId:text]', '锁定账号，防止他人登录')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }, targetUserId) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         // 检查隐藏模式
         if (hideLockAndProtection) {
-            return '❌ 该功能已禁用';
+          return '❌ 该功能已禁用'
         }
-        const userId = session.userId;
+  
+        const userId = session.userId
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
-            }
-            const binding = bindings[0];
-            // 检查是否已经锁定
-            if (binding.isLocked) {
-                const lockTime = binding.lockTime
-                    ? new Date(binding.lockTime).toLocaleString('zh-CN')
-                    : '未知';
-                return `⚠️ 账号已经锁定\n锁定时间: ${lockTime}\n使用 /mai解锁 可以解锁账号`;
-            }
-            // 确认操作
-            if (!options?.bypass) {
-                const confirm = await promptYesLocal(session, `⚠️ 即将锁定账号 ${maskUserId(binding.maiUid)}\n锁定后账号将保持登录状态，防止他人登录\n确认继续？`);
-                if (!confirm) {
-                    return '操作已取消';
-                }
-            }
-            await session.send('⏳ 正在锁定账号，请稍候...');
-            // 调用登录API锁定账号
-            const result = await api.login(binding.maiUid, machineInfo.regionId, machineInfo.placeId, machineInfo.clientId, turnstileToken);
-            if (!result.LoginStatus) {
-                if (result.UserID === -2) {
-                    return '❌ 锁定失败：Turnstile校验失败，请检查token配置';
-                }
-                return '❌ 锁定失败，服务端未返回成功状态，请稍后重试。请点击获取二维码刷新账号后再试。';
-            }
-            // 保存锁定信息到数据库，同时关闭 maialert 推送（如果之前是开启的）
-            const updateData = {
-                isLocked: true,
-                lockTime: new Date(),
-                lockLoginId: result.LoginId,
-            };
-            // 如果之前开启了推送，锁定时自动关闭
-            if (binding.alertEnabled === true) {
-                updateData.alertEnabled = false;
-                logger.info(`用户 ${userId} 锁定账号，已自动关闭 maialert 推送`);
-            }
-            await ctx.database.set('maibot_bindings', { userId }, updateData);
-            let message = `✅ 账号已锁定\n` +
-                `用户ID: ${maskUserId(binding.maiUid)}\n` +
-                `锁定时间: ${new Date().toLocaleString('zh-CN')}\n\n`;
-            if (binding.alertEnabled === true) {
-                message += `⚠️ 已自动关闭 maialert 推送（锁定期间不会收到上线/下线提醒）\n`;
-            }
-            message += `使用 /mai解锁 可以解锁账号`;
-            return message;
-        }
-        catch (error) {
-            logger.error('锁定账号失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                if (error.response.status === 401) {
-                    return `❌ 锁定失败：Turnstile校验失败，请检查token配置\n\n${maintenanceMessage}`;
-                }
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 锁定失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          const bindings = await ctx.database.get('maibot_bindings', { userId })
+          if (bindings.length === 0) {
+            return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定'
+          }
+  
+          const binding = bindings[0]
+          
+          // 检查是否已经锁定
+          if (binding.isLocked) {
+            const lockTime = binding.lockTime
+              ? new Date(binding.lockTime).toLocaleString('zh-CN')
+              : '未知'
+            return `⚠️ 账号已经锁定\n锁定时间: ${lockTime}\n使用 /mai解锁 可以解锁账号`
+          }
+  
+          // 确认操作
+          if (!options?.bypass) {
+            const confirm = await promptYesLocal(session, `⚠️ 即将锁定账号 ${maskUserId(binding.maiUid)}\n锁定后账号将保持登录状态，防止他人登录\n确认继续？`)
+            if (!confirm) {
+              return '操作已取消'
+            }
+          }
+  
+          await session.send('⏳ 正在锁定账号，请稍候...')
+  
+          // 调用登录API锁定账号
+          const result = await api.login(
+            binding.maiUid,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.clientId,
+            turnstileToken,
+          )
+  
+          if (!result.LoginStatus) {
+            if (result.UserID === -2) {
+              return '❌ 锁定失败：Turnstile校验失败，请检查token配置'
+            }
+            return '❌ 锁定失败，服务端未返回成功状态，请稍后重试。请点击获取二维码刷新账号后再试。'
+          }
+  
+          // 保存锁定信息到数据库，同时关闭 maialert 推送（如果之前是开启的）
+          const updateData: any = {
+            isLocked: true,
+            lockTime: new Date(),
+            lockLoginId: result.LoginId,
+          }
+          
+          // 如果之前开启了推送，锁定时自动关闭
+          if (binding.alertEnabled === true) {
+            updateData.alertEnabled = false
+            logger.info(`用户 ${userId} 锁定账号，已自动关闭 maialert 推送`)
+          }
+  
+          await ctx.database.set('maibot_bindings', { userId }, updateData)
+  
+          let message = `✅ 账号已锁定\n` +
+                 `用户ID: ${maskUserId(binding.maiUid)}\n` +
+                 `锁定时间: ${new Date().toLocaleString('zh-CN')}\n\n`
+          
+          if (binding.alertEnabled === true) {
+            message += `⚠️ 已自动关闭 maialert 推送（锁定期间不会收到上线/下线提醒）\n`
+          }
+          
+          message += `使用 /mai解锁 可以解锁账号`
+  
+          return message
+        } catch (error: any) {
+          logger.error('锁定账号失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            if (error.response.status === 401) {
+              return `❌ 锁定失败：Turnstile校验失败，请检查token配置\n\n${maintenanceMessage}`
+            }
+            return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+          }
+          return `❌ 锁定失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 解锁账号（登出）
      * 用法: /mai解锁
+     * @deprecated 解锁功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai解锁 [targetUserId:text]', '解锁账号（仅限通过mai锁定指令锁定的账号）')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .alias('mai逃离小黑屋')
-        .alias('mai逃离')
-        .action(async ({ session, options }, targetUserId) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .alias('mai逃离小黑屋')
+      .alias('mai逃离')
+      .action(async ({ session, options }, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         // 检查隐藏模式
         if (hideLockAndProtection) {
-            return '❌ 该功能已禁用';
+          return '❌ 该功能已禁用'
         }
+  
         try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 检查是否通过mai锁定指令锁定
-            if (!binding.isLocked) {
-                return '⚠️ 账号未锁定\n\n目前只能解锁由 /mai锁定 指令发起的账户。\n其他登录暂时无法解锁。';
-            }
-            // 确认操作
-            if (!options?.bypass) {
-                const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
-                const confirm = await promptYesLocal(session, `⚠️ 即将解锁账号 ${maskUserId(binding.maiUid)}${proxyTip}\n确认继续？`);
-                if (!confirm) {
-                    return '操作已取消';
-                }
-            }
-            await session.send('⏳ 正在解锁账号，请稍候...');
-            const result = await api.logout(binding.maiUid, machineInfo.regionId.toString(), machineInfo.clientId, machineInfo.placeId.toString(), turnstileToken);
-            if (!result.LogoutStatus) {
-                return '❌ 解锁失败，服务端未返回成功状态，请稍后重试';
-            }
-            // 清除锁定信息（如果开启了保护模式，不关闭保护模式，让它继续监控）
-            await ctx.database.set('maibot_bindings', { userId }, {
-                isLocked: false,
-                lockTime: null,
-                lockLoginId: null,
-            });
-            let message = `✅ 账号已解锁\n` +
-                `用户ID: ${maskUserId(binding.maiUid)}\n` +
-                `建议稍等片刻再登录`;
-            // 如果开启了保护模式，提示用户保护模式会继续监控
-            if (binding.protectionMode) {
-                message += `\n\n🛡️ 保护模式仍开启，系统会在检测到账号下线时自动尝试锁定`;
-            }
-            return message;
-        }
-        catch (error) {
-            logger.error('解锁账号失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 解锁失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+  
+          // 检查是否通过mai锁定指令锁定
+          if (!binding.isLocked) {
+            return '⚠️ 账号未锁定\n\n目前只能解锁由 /mai锁定 指令发起的账户。\n其他登录暂时无法解锁。'
+          }
+  
+          // 确认操作
+          if (!options?.bypass) {
+            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : ''
+            const confirm = await promptYesLocal(session, `⚠️ 即将解锁账号 ${maskUserId(binding.maiUid)}${proxyTip}\n确认继续？`)
+            if (!confirm) {
+              return '操作已取消'
+            }
+          }
+  
+          await session.send('⏳ 正在解锁账号，请稍候...')
+  
+          const result = await api.logout(
+            binding.maiUid,
+            machineInfo.regionId.toString(),
+            machineInfo.clientId,
+            machineInfo.placeId.toString(),
+            turnstileToken,
+          )
+  
+          if (!result.LogoutStatus) {
+            return '❌ 解锁失败，服务端未返回成功状态，请稍后重试'
+          }
+  
+          // 清除锁定信息（如果开启了保护模式，不关闭保护模式，让它继续监控）
+          await ctx.database.set('maibot_bindings', { userId }, {
+            isLocked: false,
+            lockTime: null,
+            lockLoginId: null,
+          })
+  
+          let message = `✅ 账号已解锁\n` +
+                 `用户ID: ${maskUserId(binding.maiUid)}\n` +
+                 `建议稍等片刻再登录`
+          
+          // 如果开启了保护模式，提示用户保护模式会继续监控
+          if (binding.protectionMode) {
+            message += `\n\n🛡️ 保护模式仍开启，系统会在检测到账号下线时自动尝试锁定`
+          }
+  
+          return message
+        } catch (error: any) {
+          logger.error('解锁账号失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+          }
+          return `❌ 解锁失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 绑定水鱼Token
      * 用法: /mai绑定水鱼 <fishToken>
@@ -1517,11 +1553,60 @@ function apply(ctx, config) {
                     }
                 }
             }
+            // 获取qr_text（交互式或从绑定中获取）
+            const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
+            if (qrTextResult.error) {
+                if (qrTextResult.needRebind) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (!rebindResult.success) {
+                        return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
+                    }
+                    // 重新绑定成功后，使用新的binding
+                    const updatedBinding = rebindResult.newBinding || binding;
+                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    }
+                    // 使用新的qrText继续
+                    await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
+                    const ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+                    if (!ticketResult.TicketStatus || !ticketResult.LoginStatus || !ticketResult.LogoutStatus) {
+                        return '❌ 发放功能票失败：服务器返回未成功，请稍后再试';
+                    }
+                    return `✅ 已为 ${maskUserId(updatedBinding.maiUid)} 发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
+                }
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
             await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-            const ticketResult = await api.getTicket(binding.maiUid, multiple, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
-            if (ticketResult.LoginStatus === false ||
-                ticketResult.LogoutStatus === false ||
-                ticketResult.TicketStatus === false) {
+            // 使用新API获取功能票（需要qr_text）
+            let ticketResult;
+            try {
+                ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, qrTextResult.qrText);
+            }
+            catch (error) {
+                // 如果API返回失败，可能需要重新绑定
+                const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                    // 重新绑定成功，重试获取功能票
+                    const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                    }
+                    ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+                }
+                else {
+                    throw error;
+                }
+            }
+            if (!ticketResult.TicketStatus || !ticketResult.LoginStatus || !ticketResult.LogoutStatus) {
+                // 如果返回失败，可能需要重新绑定
+                if (!ticketResult.QrStatus || ticketResult.LoginStatus === false) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (rebindResult.success && rebindResult.newBinding) {
+                        return `✅ 重新绑定成功！请重新执行发票操作。`;
+                    }
+                    return `❌ 发放功能票失败：服务器返回未成功\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                }
                 return '❌ 发票失败：服务器返回未成功，请确认是否已在短时间内多次执行发票指令或稍后再试或点击获取二维码刷新账号后再试。';
             }
             return `✅ 已为 ${maskUserId(binding.maiUid)} 发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
@@ -1540,68 +1625,91 @@ function apply(ctx, config) {
     /**
      * 舞里程发放 / 签到
      * 用法: /mai舞里程 <里程数>
+     * @deprecated 发舞里程功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai舞里程 <mile:number> [targetUserId:text]', '为账号发放舞里程（maimile）')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }, mileInput, targetUserId) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }, mileInput, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
-        const mile = Number(mileInput);
+  
+        const mile = Number(mileInput)
         if (!Number.isInteger(mile) || mile <= 0) {
-            return '❌ 舞里程必须是大于 0 的整数';
+          return '❌ 舞里程必须是大于 0 的整数'
         }
+  
         // 安全逻辑：必须是 1000 的倍数，且小于 99999
         if (mile % 1000 !== 0) {
-            return '❌ 舞里程必须是 1000 的倍数，例如：1000 / 2000 / 5000';
+          return '❌ 舞里程必须是 1000 的倍数，例如：1000 / 2000 / 5000'
         }
         if (mile >= 99999) {
-            return '❌ 舞里程过大，请控制在 99999 以下';
+          return '❌ 舞里程过大，请控制在 99999 以下'
         }
+  
         try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
-            // 确认操作（如果未使用 -bypass）
-            if (!options?.bypass) {
-                const baseTip = `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放 ${mile} 点舞里程${proxyTip}`;
-                const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
-                if (!confirmFirst) {
-                    return '操作已取消（第一次确认未通过）';
-                }
-                const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
-                if (!confirmSecond) {
-                    return '操作已取消（第二次确认未通过）';
-                }
-            }
-            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-            const result = await api.maimile(binding.maiUid, mile, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
-            if (result.MileStatus === false ||
-                result.LoginStatus === false ||
-                result.LogoutStatus === false) {
-                return '❌ 发放舞里程失败：服务器返回未成功，请稍后再试';
-            }
-            const current = typeof result.CurrentMile === 'number'
-                ? `\n当前舞里程：${result.CurrentMile}`
-                : '';
-            return `✅ 已为 ${maskUserId(binding.maiUid)} 发放 ${mile} 点舞里程${current}`;
-        }
-        catch (error) {
-            logger.error('发舞里程失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 发放舞里程失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+          const proxyTip = isProxy ? `（代操作用户 ${userId}）` : ''
+          
+          // 确认操作（如果未使用 -bypass）
+          if (!options?.bypass) {
+            const baseTip = `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放 ${mile} 点舞里程${proxyTip}`
+            const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`)
+            if (!confirmFirst) {
+              return '操作已取消（第一次确认未通过）'
+            }
+  
+            const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行')
+            if (!confirmSecond) {
+              return '操作已取消（第二次确认未通过）'
+            }
+          }
+  
+          await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）')
+  
+          const result = await api.maimile(
+            binding.maiUid,
+            mile,
+            machineInfo.clientId,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.placeName,
+            machineInfo.regionName,
+          )
+  
+          if (
+            result.MileStatus === false ||
+            result.LoginStatus === false ||
+            result.LogoutStatus === false
+          ) {
+            return '❌ 发放舞里程失败：服务器返回未成功，请稍后再试'
+          }
+  
+          const current = typeof result.CurrentMile === 'number'
+            ? `\n当前舞里程：${result.CurrentMile}`
+            : ''
+  
+          return `✅ 已为 ${maskUserId(binding.maiUid)} 发放 ${mile} 点舞里程${current}`
+        } catch (error: any) {
+          logger.error('发舞里程失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+          }
+          return `❌ 发放舞里程失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 上传B50到水鱼
      * 用法: /mai上传B50 [@用户id]
@@ -1628,12 +1736,71 @@ function apply(ctx, config) {
             if (maintenanceMsg) {
                 return maintenanceMsg;
             }
-            // 上传B50
-            const result = await api.uploadB50(binding.maiUid, binding.fishToken);
+            // 获取qr_text（交互式或从绑定中获取）
+            const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
+            if (qrTextResult.error) {
+                if (qrTextResult.needRebind) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (!rebindResult.success) {
+                        return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
+                    }
+                    // 重新绑定成功后，使用新的binding
+                    const updatedBinding = rebindResult.newBinding || binding;
+                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    }
+                    // 使用新的qrText继续
+                    const result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
+                    if (!result.UploadStatus) {
+                        if (result.msg === '该账号下存在未完成的任务') {
+                            return '⚠️ 当前账号已有未完成的水鱼B50任务，请稍后使用 /mai查询B50 查看任务状态，无需重复上传。';
+                        }
+                        return `❌ 上传失败：${result.msg || '未知错误'}`;
+                    }
+                    scheduleB50Notification(session, result.task_id);
+                    return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n使用 /mai查询B50 查看任务状态`;
+                }
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 上传B50（使用新API，需要qr_text）
+            let result;
+            try {
+                result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, binding.fishToken);
+            }
+            catch (error) {
+                // 如果API返回失败，可能需要重新绑定
+                const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                    // 重新绑定成功，重试上传
+                    const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                    }
+                    result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
+                }
+                else {
+                    throw error;
+                }
+            }
+            if (!result.UploadStatus) {
+                if (result.msg === '该账号下存在未完成的任务') {
+                    return '⚠️ 当前账号已有未完成的水鱼B50任务，请稍后使用 /mai查询B50 查看任务状态，无需重复上传。';
+                }
+                return `❌ 上传失败：${result.msg || '未知错误'}`;
+            }
             if (!result.UploadStatus) {
                 if (result.msg === '该账号下存在未完成的任务') {
                     return '⚠️ 当前账号已有未完成的水鱼B50任务，请稍后使用 /mai查询B50 查看任务状态，无需重复上传。';
                 }
+                // 如果返回失败，可能需要重新绑定
+                if (result.msg?.includes('二维码') || result.msg?.includes('qr_text') || result.msg?.includes('无效')) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (rebindResult.success && rebindResult.newBinding) {
+                        return `✅ 重新绑定成功！请重新执行上传操作。`;
+                    }
+                    return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                }
                 return `❌ 上传失败：${result.msg || '未知错误'}`;
             }
             scheduleB50Notification(session, result.task_id);
@@ -1663,11 +1830,120 @@ function apply(ctx, config) {
     /**
      * 清空功能票
      * 用法: /mai清票
+     * @deprecated 清票功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai清票 [targetUserId:text]', '清空账号的所有功能票')
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }, targetUserId) => {
+        if (!session) {
+          return '❌ 无法获取会话信息'
+        }
+  
+        try {
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+          const proxyTip = isProxy ? `（代操作用户 ${userId}）` : ''
+          
+          // 确认操作（如果未使用 -bypass）
+          if (!options?.bypass) {
+            const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的所有功能票${proxyTip}，确认继续？`)
+            if (!confirm) {
+              return '操作已取消'
+            }
+          }
+  
+          await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）')
+  
+          const result = await api.clearTicket(
+            binding.maiUid,
+            machineInfo.clientId,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.placeName,
+            machineInfo.regionName,
+          )
+  
+          // 检查4个状态字段是否都是 true
+          const loginStatus = result.LoginStatus === true
+          const logoutStatus = result.LogoutStatus === true
+          const userAllStatus = result.UserAllStatus === true
+          const userLogStatus = result.UserLogStatus === true
+  
+          // 如果4个状态都是 true，则清票成功
+          if (loginStatus && logoutStatus && userAllStatus && userLogStatus) {
+            return `✅ 已清空 ${maskUserId(binding.maiUid)} 的所有功能票`
+          }
+  
+          // 如果4个状态都是 false，需要重新绑定二维码
+          if (checkAllStatusFalse(result)) {
+            await session.send('🔄 二维码已失效，需要重新绑定后才能继续操作')
+            const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout)
+            if (rebindResult.success && rebindResult.newBinding) {
+              // 重新绑定成功后，尝试再次清票
+              try {
+                await session.send('⏳ 重新绑定成功，正在重新执行清票操作...')
+                const retryResult = await api.clearTicket(
+                  rebindResult.newBinding.maiUid,
+                  machineInfo.clientId,
+                  machineInfo.regionId,
+                  machineInfo.placeId,
+                  machineInfo.placeName,
+                  machineInfo.regionName,
+                )
+                
+                if (checkAllStatusFalse(retryResult)) {
+                  await session.send('❌ 重新绑定后清票仍然失败，请检查二维码是否正确')
+                  return `❌ 重新绑定后清票仍然失败\n错误信息： ${JSON.stringify(retryResult)}`
+                }
+                
+                const retryLoginStatus = retryResult.LoginStatus === true
+                const retryLogoutStatus = retryResult.LogoutStatus === true
+                const retryUserAllStatus = retryResult.UserAllStatus === true
+                const retryUserLogStatus = retryResult.UserLogStatus === true
+  
+                if (retryLoginStatus && retryLogoutStatus && retryUserAllStatus && retryUserLogStatus) {
+                  return `✅ 重新绑定成功！已清空 ${maskUserId(rebindResult.newBinding.maiUid)} 的所有功能票`
+                }
+                
+                return `⚠️ 重新绑定成功，但清票部分失败\n错误信息： ${JSON.stringify(retryResult)}`
+              } catch (retryError) {
+                logger.error('重新绑定后清票失败:', retryError)
+                return `✅ 重新绑定成功，但清票操作失败，请稍后重试`
+              }
+            } else {
+              return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`
+            }
+          }
+  
+          // 其他失败情况，显示详细错误信息
+          return `❌ 清票失败\n错误信息： ${JSON.stringify(result)}`
+        } catch (error: any) {
+          logger.error('清票失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            const errorInfo = error.response.data ? JSON.stringify(error.response.data) : `${error.response.status} ${error.response.statusText}`
+            return `❌ API请求失败\n错误信息： ${errorInfo}\n\n${maintenanceMessage}`
+          }
+          return `❌ 清票失败\n错误信息： ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
+    /**
+     * 查询B50任务状态
+     * 用法: /mai查询B50
+     */
+    ctx.command('mai查询B50 [targetUserId:text]', '查询B50上传任务状态')
         .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }, targetUserId) => {
+        .action(async ({ session }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -1678,102 +1954,26 @@ function apply(ctx, config) {
                 return error || '❌ 获取用户绑定失败';
             }
             const userId = binding.userId;
-            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
-            // 确认操作（如果未使用 -bypass）
-            if (!options?.bypass) {
-                const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的所有功能票${proxyTip}，确认继续？`);
-                if (!confirm) {
-                    return '操作已取消';
-                }
+            // 查询任务状态
+            const taskStatus = await api.getB50TaskStatus(binding.maiUid);
+            if (taskStatus.code !== 0 || !taskStatus.alive_task_id) {
+                return 'ℹ️ 当前没有正在进行的B50上传任务';
             }
-            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-            const result = await api.clearTicket(binding.maiUid, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
-            // 检查4个状态字段是否都是 true
-            const loginStatus = result.LoginStatus === true;
-            const logoutStatus = result.LogoutStatus === true;
-            const userAllStatus = result.UserAllStatus === true;
-            const userLogStatus = result.UserLogStatus === true;
-            // 如果4个状态都是 true，则清票成功
-            if (loginStatus && logoutStatus && userAllStatus && userLogStatus) {
-                return `✅ 已清空 ${maskUserId(binding.maiUid)} 的所有功能票`;
-            }
-            // 如果4个状态都是 false，需要重新绑定二维码
-            if (checkAllStatusFalse(result)) {
-                await session.send('🔄 二维码已失效，需要重新绑定后才能继续操作');
-                const rebindResult = await promptForRebind(session, ctx, api, binding, rebindTimeout);
-                if (rebindResult.success && rebindResult.newBinding) {
-                    // 重新绑定成功后，尝试再次清票
-                    try {
-                        await session.send('⏳ 重新绑定成功，正在重新执行清票操作...');
-                        const retryResult = await api.clearTicket(rebindResult.newBinding.maiUid, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
-                        if (checkAllStatusFalse(retryResult)) {
-                            await session.send('❌ 重新绑定后清票仍然失败，请检查二维码是否正确');
-                            return `❌ 重新绑定后清票仍然失败\n错误信息： ${JSON.stringify(retryResult)}`;
-                        }
-                        const retryLoginStatus = retryResult.LoginStatus === true;
-                        const retryLogoutStatus = retryResult.LogoutStatus === true;
-                        const retryUserAllStatus = retryResult.UserAllStatus === true;
-                        const retryUserLogStatus = retryResult.UserLogStatus === true;
-                        if (retryLoginStatus && retryLogoutStatus && retryUserAllStatus && retryUserLogStatus) {
-                            return `✅ 重新绑定成功！已清空 ${maskUserId(rebindResult.newBinding.maiUid)} 的所有功能票`;
-                        }
-                        return `⚠️ 重新绑定成功，但清票部分失败\n错误信息： ${JSON.stringify(retryResult)}`;
-                    }
-                    catch (retryError) {
-                        logger.error('重新绑定后清票失败:', retryError);
-                        return `✅ 重新绑定成功，但清票操作失败，请稍后重试`;
-                    }
-                }
-                else {
-                    return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
-                }
-            }
-            // 其他失败情况，显示详细错误信息
-            return `❌ 清票失败\n错误信息： ${JSON.stringify(result)}`;
-        }
-        catch (error) {
-            logger.error('清票失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                const errorInfo = error.response.data ? JSON.stringify(error.response.data) : `${error.response.status} ${error.response.statusText}`;
-                return `❌ API请求失败\n错误信息： ${errorInfo}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 清票失败\n错误信息： ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
-    /**
-     * 查询B50任务状态
-     * 用法: /mai查询B50
-     */
-    ctx.command('mai查询B50 [targetUserId:text]', '查询B50上传任务状态')
-        .userFields(['authority'])
-        .action(async ({ session }, targetUserId) => {
-        if (!session) {
-            return '❌ 无法获取会话信息';
-        }
-        try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 查询任务状态
-            const taskStatus = await api.getB50TaskStatus(binding.maiUid);
-            if (taskStatus.code !== 0 || !taskStatus.alive_task_id) {
-                return 'ℹ️ 当前没有正在进行的B50上传任务';
-            }
-            // 查询任务详情
-            const taskDetail = await api.getB50TaskById(taskStatus.alive_task_id);
-            let statusInfo = `📊 B50上传任务状态\n\n` +
-                `任务ID: ${taskStatus.alive_task_id}\n` +
-                `开始时间: ${new Date(parseInt(taskStatus.alive_task_time) * 1000).toLocaleString('zh-CN')}\n`;
-            if (taskDetail.done) {
-                statusInfo += `状态: ✅ 已完成\n`;
-                if (taskDetail.alive_task_end_time) {
-                    statusInfo += `完成时间: ${new Date(parseInt(taskDetail.alive_task_end_time) * 1000).toLocaleString('zh-CN')}\n`;
+            // 查询任务详情
+            const taskDetail = await api.getB50TaskById(String(taskStatus.alive_task_id));
+            const startTime = typeof taskStatus.alive_task_time === 'number'
+                ? taskStatus.alive_task_time
+                : parseInt(String(taskStatus.alive_task_time));
+            let statusInfo = `📊 B50上传任务状态\n\n` +
+                `任务ID: ${taskStatus.alive_task_id}\n` +
+                `开始时间: ${new Date(startTime * 1000).toLocaleString('zh-CN')}\n`;
+            if (taskDetail.done) {
+                statusInfo += `状态: ✅ 已完成\n`;
+                if (taskDetail.alive_task_end_time) {
+                    const endTime = typeof taskDetail.alive_task_end_time === 'number'
+                        ? taskDetail.alive_task_end_time
+                        : parseInt(String(taskDetail.alive_task_end_time));
+                    statusInfo += `完成时间: ${new Date(endTime * 1000).toLocaleString('zh-CN')}\n`;
                 }
                 if (taskDetail.error) {
                     statusInfo += `错误信息: ${taskDetail.error}\n`;
@@ -1798,233 +1998,335 @@ function apply(ctx, config) {
     /**
      * 发收藏品
      * 用法: /mai发收藏品
+     * @deprecated 发收藏品功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai发收藏品 [targetUserId:text]', '发放收藏品')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }, targetUserId) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 交互式选择收藏品类别
-            const itemKind = await promptCollectionType(session);
-            if (itemKind === null) {
-                return '操作已取消';
-            }
-            const selectedType = COLLECTION_TYPE_OPTIONS.find(opt => opt.value === itemKind);
-            await session.send(`已选择：${selectedType?.label} (${itemKind})\n\n` +
-                `请输入收藏品ID（数字）\n` +
-                `如果不知道收藏品ID，请前往 https://sdgb.lemonno.xyz/ 查询\n` +
-                `乐曲解禁请输入乐曲ID\n\n` +
-                `输入0取消操作`);
-            const itemIdInput = await session.prompt(60000);
-            if (!itemIdInput || itemIdInput.trim() === '0') {
-                return '操作已取消';
-            }
-            const itemId = itemIdInput.trim();
-            // 验证ID是否为数字
-            if (!/^\d+$/.test(itemId)) {
-                return '❌ ID必须是数字，请重新输入';
-            }
-            const confirm = await promptYesLocal(session, `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放收藏品\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`);
-            if (!confirm) {
-                return '操作已取消';
-            }
-            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-            const result = await api.getItem(binding.maiUid, itemId, itemKind.toString(), machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
-            if (result.ItemStatus === false || result.LoginStatus === false || result.LogoutStatus === false) {
-                return '❌ 发放失败：服务器未返回成功状态，请稍后再试或点击获取二维码刷新账号后再试。';
-            }
-            return `✅ 已为 ${maskUserId(binding.maiUid)} 发放收藏品\n类型: ${selectedType?.label}\nID: ${itemId}`;
-        }
-        catch (error) {
-            logger.error('发收藏品失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 发放失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+  
+          // 交互式选择收藏品类别
+          const itemKind = await promptCollectionType(session)
+          if (itemKind === null) {
+            return '操作已取消'
+          }
+  
+          const selectedType = COLLECTION_TYPE_OPTIONS.find(opt => opt.value === itemKind)
+          await session.send(
+            `已选择：${selectedType?.label} (${itemKind})\n\n` +
+            `请输入收藏品ID（数字）\n` +
+            `如果不知道收藏品ID，请前往 https://sdgb.lemonno.xyz/ 查询\n` +
+            `乐曲解禁请输入乐曲ID\n\n` +
+            `输入0取消操作`
+          )
+  
+          const itemIdInput = await session.prompt(60000)
+          if (!itemIdInput || itemIdInput.trim() === '0') {
+            return '操作已取消'
+          }
+  
+          const itemId = itemIdInput.trim()
+          // 验证ID是否为数字
+          if (!/^\d+$/.test(itemId)) {
+            return '❌ ID必须是数字，请重新输入'
+          }
+  
+          const confirm = await promptYesLocal(
+            session,
+            `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放收藏品\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`
+          )
+          if (!confirm) {
+            return '操作已取消'
+          }
+  
+          await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）')
+  
+          const result = await api.getItem(
+            binding.maiUid,
+            itemId,
+            itemKind.toString(),
+            machineInfo.clientId,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.placeName,
+            machineInfo.regionName,
+          )
+  
+          if (result.ItemStatus === false || result.LoginStatus === false || result.LogoutStatus === false) {
+            return '❌ 发放失败：服务器未返回成功状态，请稍后再试或点击获取二维码刷新账号后再试。'
+          }
+  
+          return `✅ 已为 ${maskUserId(binding.maiUid)} 发放收藏品\n类型: ${selectedType?.label}\nID: ${itemId}`
+        } catch (error: any) {
+          logger.error('发收藏品失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+          }
+          return `❌ 发放失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 清收藏品
      * 用法: /mai清收藏品
+     * @deprecated 清收藏品功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai清收藏品 [targetUserId:text]', '清空收藏品')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }, targetUserId) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 交互式选择收藏品类别
-            const itemKind = await promptCollectionType(session);
-            if (itemKind === null) {
-                return '操作已取消';
-            }
-            const selectedType = COLLECTION_TYPE_OPTIONS.find(opt => opt.value === itemKind);
-            await session.send(`已选择：${selectedType?.label} (${itemKind})\n\n` +
-                `请输入收藏品ID（数字）\n` +
-                `如果不知道收藏品ID，请前往 https://sdgb.lemonno.xyz/ 查询\n` +
-                `乐曲解禁请输入乐曲ID\n\n` +
-                `输入0取消操作`);
-            const itemIdInput = await session.prompt(60000);
-            if (!itemIdInput || itemIdInput.trim() === '0') {
-                return '操作已取消';
-            }
-            const itemId = itemIdInput.trim();
-            // 验证ID是否为数字
-            if (!/^\d+$/.test(itemId)) {
-                return '❌ ID必须是数字，请重新输入';
-            }
-            // 确认操作（如果未使用 -bypass）
-            if (!options?.bypass) {
-                const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的收藏品\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`);
-                if (!confirm) {
-                    return '操作已取消';
-                }
-            }
-            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-            const result = await api.clearItem(binding.maiUid, itemId, itemKind.toString(), machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
-            if (result.ClearStatus === false || result.LoginStatus === false || result.LogoutStatus === false) {
-                return '❌ 清空失败：服务器未返回成功状态，请稍后再试或点击获取二维码刷新账号后再试。';
-            }
-            return `✅ 已清空 ${maskUserId(binding.maiUid)} 的收藏品\n类型: ${selectedType?.label}\nID: ${itemId}`;
-        }
-        catch (error) {
-            logger.error('清收藏品失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 清空失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+  
+          // 交互式选择收藏品类别
+          const itemKind = await promptCollectionType(session)
+          if (itemKind === null) {
+            return '操作已取消'
+          }
+  
+          const selectedType = COLLECTION_TYPE_OPTIONS.find(opt => opt.value === itemKind)
+          await session.send(
+            `已选择：${selectedType?.label} (${itemKind})\n\n` +
+            `请输入收藏品ID（数字）\n` +
+            `如果不知道收藏品ID，请前往 https://sdgb.lemonno.xyz/ 查询\n` +
+            `乐曲解禁请输入乐曲ID\n\n` +
+            `输入0取消操作`
+          )
+  
+          const itemIdInput = await session.prompt(60000)
+          if (!itemIdInput || itemIdInput.trim() === '0') {
+            return '操作已取消'
+          }
+  
+          const itemId = itemIdInput.trim()
+          // 验证ID是否为数字
+          if (!/^\d+$/.test(itemId)) {
+            return '❌ ID必须是数字，请重新输入'
+          }
+  
+          // 确认操作（如果未使用 -bypass）
+          if (!options?.bypass) {
+            const confirm = await promptYesLocal(
+              session,
+              `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的收藏品\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`
+            )
+            if (!confirm) {
+              return '操作已取消'
+            }
+          }
+  
+          await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）')
+  
+          const result = await api.clearItem(
+            binding.maiUid,
+            itemId,
+            itemKind.toString(),
+            machineInfo.clientId,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.placeName,
+            machineInfo.regionName,
+          )
+  
+          if (result.ClearStatus === false || result.LoginStatus === false || result.LogoutStatus === false) {
+            return '❌ 清空失败：服务器未返回成功状态，请稍后再试或点击获取二维码刷新账号后再试。'
+          }
+  
+          return `✅ 已清空 ${maskUserId(binding.maiUid)} 的收藏品\n类型: ${selectedType?.label}\nID: ${itemId}`
+        } catch (error: any) {
+          logger.error('清收藏品失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+          }
+          return `❌ 清空失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 上传乐曲成绩
      * 用法: /mai上传乐曲成绩
+     * @deprecated 上传乐曲成绩功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai上传乐曲成绩 [targetUserId:text]', '上传游戏乐曲成绩')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }, targetUserId) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 交互式输入乐曲成绩数据
-            const scoreData = await promptScoreData(session);
-            if (!scoreData) {
-                return '操作已取消';
-            }
-            const levelLabel = LEVEL_OPTIONS.find(opt => opt.value === scoreData.level)?.label || scoreData.level.toString();
-            const fcLabel = FC_STATUS_OPTIONS.find(opt => opt.value === scoreData.fcStatus)?.label || scoreData.fcStatus.toString();
-            const syncLabel = SYNC_STATUS_OPTIONS.find(opt => opt.value === scoreData.syncStatus)?.label || scoreData.syncStatus.toString();
-            // 确认操作（如果未使用 -bypass）
-            if (!options?.bypass) {
-                const confirm = await promptYesLocal(session, `⚠️ 即将为 ${maskUserId(binding.maiUid)} 上传乐曲成绩\n` +
-                    `乐曲ID: ${scoreData.musicId}\n` +
-                    `难度等级: ${levelLabel} (${scoreData.level})\n` +
-                    `达成率: ${scoreData.achievement}\n` +
-                    `Full Combo: ${fcLabel} (${scoreData.fcStatus})\n` +
-                    `同步状态: ${syncLabel} (${scoreData.syncStatus})\n` +
-                    `DX分数: ${scoreData.dxScore}\n` +
-                    `确认继续？`);
-                if (!confirm) {
-                    return '操作已取消';
-                }
-            }
-            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-            const result = await api.uploadScore(binding.maiUid, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName, scoreData.musicId, scoreData.level, scoreData.achievement, scoreData.fcStatus, scoreData.syncStatus, scoreData.dxScore);
-            // 检查4个状态字段是否都是 true
-            const loginStatus = result.LoginStatus === true;
-            const logoutStatus = result.LogoutStatus === true;
-            const uploadStatus = result.UploadStatus === true;
-            const userLogStatus = result.UserLogStatus === true;
-            // 如果4个状态都是 true，则上传成功
-            if (loginStatus && logoutStatus && uploadStatus && userLogStatus) {
-                return `✅ 已为 ${maskUserId(binding.maiUid)} 上传乐曲成绩\n` +
-                    `乐曲ID: ${scoreData.musicId}\n` +
-                    `难度: ${levelLabel}`;
-            }
-            // 如果4个状态都是 false，需要重新绑定二维码
-            if (result.LoginStatus === false &&
-                result.LogoutStatus === false &&
-                result.UploadStatus === false &&
-                result.UserLogStatus === false) {
-                await session.send('🔄 二维码已失效，需要重新绑定后才能继续操作');
-                const rebindResult = await promptForRebind(session, ctx, api, binding, rebindTimeout);
-                if (rebindResult.success && rebindResult.newBinding) {
-                    // 重新绑定成功后，尝试再次上传
-                    try {
-                        await session.send('⏳ 重新绑定成功，正在重新执行上传操作...');
-                        const retryResult = await api.uploadScore(rebindResult.newBinding.maiUid, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName, scoreData.musicId, scoreData.level, scoreData.achievement, scoreData.fcStatus, scoreData.syncStatus, scoreData.dxScore);
-                        if (retryResult.LoginStatus === false &&
-                            retryResult.LogoutStatus === false &&
-                            retryResult.UploadStatus === false &&
-                            retryResult.UserLogStatus === false) {
-                            await session.send('❌ 重新绑定后上传仍然失败，请检查二维码是否正确');
-                            return `❌ 重新绑定后上传仍然失败\n错误信息： ${JSON.stringify(retryResult)}`;
-                        }
-                        const retryLoginStatus = retryResult.LoginStatus === true;
-                        const retryLogoutStatus = retryResult.LogoutStatus === true;
-                        const retryUploadStatus = retryResult.UploadStatus === true;
-                        const retryUserLogStatus = retryResult.UserLogStatus === true;
-                        if (retryLoginStatus && retryLogoutStatus && retryUploadStatus && retryUserLogStatus) {
-                            return `✅ 重新绑定成功！已为 ${maskUserId(rebindResult.newBinding.maiUid)} 上传乐曲成绩\n` +
-                                `乐曲ID: ${scoreData.musicId}\n` +
-                                `难度: ${levelLabel}`;
-                        }
-                        return `⚠️ 重新绑定成功，但上传部分失败\n错误信息： ${JSON.stringify(retryResult)}`;
-                    }
-                    catch (retryError) {
-                        logger.error('重新绑定后上传失败:', retryError);
-                        return `✅ 重新绑定成功，但上传操作失败，请稍后重试`;
-                    }
-                }
-                else {
-                    return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
-                }
-            }
-            // 其他失败情况，显示详细错误信息
-            return `❌ 上传失败\n错误信息： ${JSON.stringify(result)}`;
-        }
-        catch (error) {
-            logger.error('上传乐曲成绩失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            if (error?.response) {
-                const errorInfo = error.response.data ? JSON.stringify(error.response.data) : `${error.response.status} ${error.response.statusText}`;
-                return `❌ API请求失败\n错误信息： ${errorInfo}\n\n${maintenanceMessage}`;
-            }
-            return `❌ 上传失败\n错误信息： ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+  
+          // 交互式输入乐曲成绩数据
+          const scoreData = await promptScoreData(session)
+          if (!scoreData) {
+            return '操作已取消'
+          }
+  
+          const levelLabel = LEVEL_OPTIONS.find(opt => opt.value === scoreData.level)?.label || scoreData.level.toString()
+          const fcLabel = FC_STATUS_OPTIONS.find(opt => opt.value === scoreData.fcStatus)?.label || scoreData.fcStatus.toString()
+          const syncLabel = SYNC_STATUS_OPTIONS.find(opt => opt.value === scoreData.syncStatus)?.label || scoreData.syncStatus.toString()
+  
+          // 确认操作（如果未使用 -bypass）
+          if (!options?.bypass) {
+            const confirm = await promptYesLocal(
+              session,
+              `⚠️ 即将为 ${maskUserId(binding.maiUid)} 上传乐曲成绩\n` +
+              `乐曲ID: ${scoreData.musicId}\n` +
+              `难度等级: ${levelLabel} (${scoreData.level})\n` +
+              `达成率: ${scoreData.achievement}\n` +
+              `Full Combo: ${fcLabel} (${scoreData.fcStatus})\n` +
+              `同步状态: ${syncLabel} (${scoreData.syncStatus})\n` +
+              `DX分数: ${scoreData.dxScore}\n` +
+              `确认继续？`
+            )
+            if (!confirm) {
+              return '操作已取消'
+            }
+          }
+  
+          await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）')
+  
+          const result = await api.uploadScore(
+            binding.maiUid,
+            machineInfo.clientId,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.placeName,
+            machineInfo.regionName,
+            scoreData.musicId,
+            scoreData.level,
+            scoreData.achievement,
+            scoreData.fcStatus,
+            scoreData.syncStatus,
+            scoreData.dxScore,
+          )
+  
+          // 检查4个状态字段是否都是 true
+          const loginStatus = result.LoginStatus === true
+          const logoutStatus = result.LogoutStatus === true
+          const uploadStatus = result.UploadStatus === true
+          const userLogStatus = result.UserLogStatus === true
+  
+          // 如果4个状态都是 true，则上传成功
+          if (loginStatus && logoutStatus && uploadStatus && userLogStatus) {
+            return `✅ 已为 ${maskUserId(binding.maiUid)} 上传乐曲成绩\n` +
+                   `乐曲ID: ${scoreData.musicId}\n` +
+                   `难度: ${levelLabel}`
+          }
+  
+          // 如果4个状态都是 false，需要重新绑定二维码
+          if (
+            result.LoginStatus === false &&
+            result.LogoutStatus === false &&
+            result.UploadStatus === false &&
+            result.UserLogStatus === false
+          ) {
+            await session.send('🔄 二维码已失效，需要重新绑定后才能继续操作')
+            const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout)
+            if (rebindResult.success && rebindResult.newBinding) {
+              // 重新绑定成功后，尝试再次上传
+              try {
+                await session.send('⏳ 重新绑定成功，正在重新执行上传操作...')
+                const retryResult = await api.uploadScore(
+                  rebindResult.newBinding.maiUid,
+                  machineInfo.clientId,
+                  machineInfo.regionId,
+                  machineInfo.placeId,
+                  machineInfo.placeName,
+                  machineInfo.regionName,
+                  scoreData.musicId,
+                  scoreData.level,
+                  scoreData.achievement,
+                  scoreData.fcStatus,
+                  scoreData.syncStatus,
+                  scoreData.dxScore,
+                )
+                
+                if (
+                  retryResult.LoginStatus === false &&
+                  retryResult.LogoutStatus === false &&
+                  retryResult.UploadStatus === false &&
+                  retryResult.UserLogStatus === false
+                ) {
+                  await session.send('❌ 重新绑定后上传仍然失败，请检查二维码是否正确')
+                  return `❌ 重新绑定后上传仍然失败\n错误信息： ${JSON.stringify(retryResult)}`
+                }
+                
+                const retryLoginStatus = retryResult.LoginStatus === true
+                const retryLogoutStatus = retryResult.LogoutStatus === true
+                const retryUploadStatus = retryResult.UploadStatus === true
+                const retryUserLogStatus = retryResult.UserLogStatus === true
+  
+                if (retryLoginStatus && retryLogoutStatus && retryUploadStatus && retryUserLogStatus) {
+                  return `✅ 重新绑定成功！已为 ${maskUserId(rebindResult.newBinding.maiUid)} 上传乐曲成绩\n` +
+                         `乐曲ID: ${scoreData.musicId}\n` +
+                         `难度: ${levelLabel}`
+                }
+                
+                return `⚠️ 重新绑定成功，但上传部分失败\n错误信息： ${JSON.stringify(retryResult)}`
+              } catch (retryError) {
+                logger.error('重新绑定后上传失败:', retryError)
+                return `✅ 重新绑定成功，但上传操作失败，请稍后重试`
+              }
+            } else {
+              return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`
+            }
+          }
+  
+          // 其他失败情况，显示详细错误信息
+          return `❌ 上传失败\n错误信息： ${JSON.stringify(result)}`
+        } catch (error: any) {
+          logger.error('上传乐曲成绩失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          if (error?.response) {
+            const errorInfo = error.response.data ? JSON.stringify(error.response.data) : `${error.response.status} ${error.response.statusText}`
+            return `❌ API请求失败\n错误信息： ${errorInfo}\n\n${maintenanceMessage}`
+          }
+          return `❌ 上传失败\n错误信息： ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 上传落雪B50
      * 用法: /mai上传落雪b50 [lxns_code] [@用户id]
@@ -2064,14 +2366,73 @@ function apply(ctx, config) {
             if (maintenanceMsg) {
                 return maintenanceMsg;
             }
-            // 上传落雪B50
-            const result = await api.uploadLxB50(binding.maiUid, finalLxnsCode);
+            // 获取qr_text（交互式或从绑定中获取）
+            const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
+            if (qrTextResult.error) {
+                if (qrTextResult.needRebind) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (!rebindResult.success) {
+                        return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
+                    }
+                    // 重新绑定成功后，使用新的binding
+                    const updatedBinding = rebindResult.newBinding || binding;
+                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    }
+                    // 使用新的qrText继续
+                    const result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                    if (!result.UploadStatus) {
+                        if (result.msg === '该账号下存在未完成的任务') {
+                            return '⚠️ 当前账号已有未完成的落雪B50任务，请稍后使用 /mai查询落雪B50 查看任务状态，无需重复上传。';
+                        }
+                        return `❌ 上传失败：${result.msg || '未知错误'}`;
+                    }
+                    scheduleLxB50Notification(session, result.task_id);
+                    return `✅ 落雪B50上传任务已提交！\n任务ID: ${result.task_id}\n\n使用 /mai查询落雪B50 查看任务状态`;
+                }
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 上传落雪B50（使用新API，需要qr_text）
+            let result;
+            try {
+                result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
+            }
+            catch (error) {
+                // 如果API返回失败，可能需要重新绑定
+                const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                    // 重新绑定成功，重试上传
+                    const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                    }
+                    result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                }
+                else {
+                    throw error;
+                }
+            }
             if (!result.UploadStatus) {
                 if (result.msg === '该账号下存在未完成的任务') {
                     return '⚠️ 当前账号已有未完成的落雪B50任务，请稍后使用 /mai查询落雪B50 查看任务状态，无需重复上传。';
                 }
                 return `❌ 上传失败：${result.msg || '未知错误'}`;
             }
+            if (!result.UploadStatus) {
+                if (result.msg === '该账号下存在未完成的任务') {
+                    return '⚠️ 当前账号已有未完成的落雪B50任务，请稍后使用 /mai查询落雪B50 查看任务状态，无需重复上传。';
+                }
+                // 如果返回失败，可能需要重新绑定
+                if (result.msg?.includes('二维码') || result.msg?.includes('qr_text') || result.msg?.includes('无效')) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (rebindResult.success && rebindResult.newBinding) {
+                        return `✅ 重新绑定成功！请重新执行上传操作。`;
+                    }
+                    return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                }
+                return `❌ 上传失败：${result.msg || '未知错误'}`;
+            }
             scheduleLxB50Notification(session, result.task_id);
             return `✅ 落雪B50上传任务已提交！\n任务ID: ${result.task_id}\n\n使用 /mai查询落雪B50 查看任务状态`;
         }
@@ -2119,14 +2480,20 @@ function apply(ctx, config) {
                 return 'ℹ️ 当前没有正在进行的落雪B50上传任务';
             }
             // 查询任务详情
-            const taskDetail = await api.getLxB50TaskById(taskStatus.alive_task_id);
+            const taskDetail = await api.getLxB50TaskById(String(taskStatus.alive_task_id));
+            const startTime = typeof taskStatus.alive_task_time === 'number'
+                ? taskStatus.alive_task_time
+                : parseInt(String(taskStatus.alive_task_time));
             let statusInfo = `📊 落雪B50上传任务状态\n\n` +
                 `任务ID: ${taskStatus.alive_task_id}\n` +
-                `开始时间: ${new Date(parseInt(taskStatus.alive_task_time) * 1000).toLocaleString('zh-CN')}\n`;
+                `开始时间: ${new Date(startTime * 1000).toLocaleString('zh-CN')}\n`;
             if (taskDetail.done) {
                 statusInfo += `状态: ✅ 已完成\n`;
                 if (taskDetail.alive_task_end_time) {
-                    statusInfo += `完成时间: ${new Date(parseInt(taskDetail.alive_task_end_time) * 1000).toLocaleString('zh-CN')}\n`;
+                    const endTime = typeof taskDetail.alive_task_end_time === 'number'
+                        ? taskDetail.alive_task_end_time
+                        : parseInt(String(taskDetail.alive_task_end_time));
+                    statusInfo += `完成时间: ${new Date(endTime * 1000).toLocaleString('zh-CN')}\n`;
                 }
                 if (taskDetail.error) {
                     statusInfo += `错误信息: ${taskDetail.error}\n`;
@@ -2148,6 +2515,71 @@ function apply(ctx, config) {
             return `❌ 查询失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
         }
     });
+    /**
+     * 查询选项文件（OPT）
+     * 用法: /mai查询opt <title_ver>
+     * 权限: auth3
+     */
+    ctx.command('mai查询opt <titleVer:text>', '查询Mai2选项文件下载地址')
+        .userFields(['authority'])
+        .action(async ({ session }, titleVer) => {
+        if (!session) {
+            return '❌ 无法获取会话信息';
+        }
+        // 检查权限（auth3）
+        if (session.user?.authority !== 3) {
+            return '❌ 权限不足，此功能需要auth等级3';
+        }
+        if (!titleVer) {
+            return '❌ 请提供游戏版本号\n用法：/mai查询opt <title_ver>\n例如：/mai查询opt 1.00';
+        }
+        try {
+            const result = await api.getOpt(titleVer, machineInfo.clientId);
+            if (result.error) {
+                return `❌ 查询失败：${result.error}`;
+            }
+            let message = `✅ 选项文件查询成功\n\n`;
+            message += `游戏版本: ${titleVer}\n`;
+            message += `客户端ID: ${machineInfo.clientId}\n\n`;
+            if (result.app_url && result.app_url.length > 0) {
+                message += `📦 APP文件 (${result.app_url.length}个):\n`;
+                result.app_url.forEach((url, index) => {
+                    message += `${index + 1}. ${url}\n`;
+                });
+                message += `\n`;
+            }
+            else {
+                message += `📦 APP文件: 无\n\n`;
+            }
+            if (result.opt_url && result.opt_url.length > 0) {
+                message += `📦 OPT文件 (${result.opt_url.length}个):\n`;
+                result.opt_url.forEach((url, index) => {
+                    message += `${index + 1}. ${url}\n`;
+                });
+                message += `\n`;
+            }
+            else {
+                message += `📦 OPT文件: 无\n\n`;
+            }
+            if (result.latest_app_time) {
+                message += `最新APP发布时间: ${result.latest_app_time}\n`;
+            }
+            if (result.latest_opt_time) {
+                message += `最新OPT发布时间: ${result.latest_opt_time}\n`;
+            }
+            return message;
+        }
+        catch (error) {
+            logger.error('查询OPT失败:', error);
+            if (maintenanceMode) {
+                return maintenanceMessage;
+            }
+            if (error?.response) {
+                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+            }
+            return `❌ 查询失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
+        }
+    });
     // 提醒功能配置
     const alertMessages = config.alertMessages || {
         loginMessage: '{playerid}{at} 你的账号已上线。',
@@ -2193,9 +2625,14 @@ function apply(ctx, config) {
             const lastSavedStatus = current.lastLoginStatus;
             logger.debug(`用户 ${binding.userId} 数据库中保存的上一次状态: ${lastSavedStatus} (类型: ${typeof lastSavedStatus})`);
             // 获取当前登录状态
-            const preview = await api.preview(binding.maiUid);
-            const currentLoginStatus = parseLoginStatus(preview.IsLogin);
-            logger.info(`用户 ${binding.userId} 当前API返回的登录状态: ${currentLoginStatus} (IsLogin原始值: "${preview.IsLogin}", 类型: ${typeof preview.IsLogin})`);
+            // 使用新API获取用户信息（需要qr_text）
+            if (!binding.qrCode) {
+                logger.warn(`用户 ${binding.userId} 没有qrCode，跳过状态检查`);
+                return;
+            }
+            const preview = await api.getPreview(machineInfo.clientId, binding.qrCode);
+            const currentLoginStatus = preview.IsLogin === true;
+            logger.info(`用户 ${binding.userId} 当前API返回的登录状态: ${currentLoginStatus} (IsLogin: ${preview.IsLogin})`);
             // 比较数据库中的上一次状态和当前状态（在更新数据库之前比较）
             // 如果 lastSavedStatus 是 undefined，说明是首次检查，不发送消息
             const statusChanged = lastSavedStatus !== undefined && lastSavedStatus !== currentLoginStatus;
@@ -2342,252 +2779,304 @@ function apply(ctx, config) {
     }, 5000); // 5秒后执行首次检查
     /**
      * 刷新单个锁定账号的登录状态
+     * @deprecated 锁定功能已在新API中移除，已注释
      */
-    const refreshSingleLockedAccount = async (binding) => {
-        // 检查插件是否还在运行
+    /*
+    const refreshSingleLockedAccount = async (binding: UserBinding) => {
+      // 检查插件是否还在运行
+      if (!isPluginActive) {
+        logger.debug('插件已停止，跳过刷新登录状态')
+        return
+      }
+  
+      try {
+        // 在执行 login 前，再次检查账号是否仍然被锁定（可能在并发执行过程中被解锁了）
+        const currentBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId })
+        if (currentBinding.length === 0 || !currentBinding[0].isLocked) {
+          logger.debug(`用户 ${binding.userId} 账号已解锁，跳过刷新登录状态`)
+          return
+        }
+  
+        // 再次检查插件状态
         if (!isPluginActive) {
-            logger.debug('插件已停止，跳过刷新登录状态');
-            return;
-        }
-        try {
-            // 在执行 login 前，再次检查账号是否仍然被锁定（可能在并发执行过程中被解锁了）
-            const currentBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
-            if (currentBinding.length === 0 || !currentBinding[0].isLocked) {
-                logger.debug(`用户 ${binding.userId} 账号已解锁，跳过刷新登录状态`);
-                return;
-            }
-            // 再次检查插件状态
-            if (!isPluginActive) {
-                logger.debug('插件已停止，取消登录请求');
-                return;
-            }
-            logger.debug(`刷新用户 ${binding.userId} (maiUid: ${maskUserId(binding.maiUid)}) 的登录状态`);
-            // 重新执行登录
-            const result = await api.login(binding.maiUid, machineInfo.regionId, machineInfo.placeId, machineInfo.clientId, turnstileToken);
-            if (result.LoginStatus) {
-                // 更新LoginId（如果有变化）
-                if (result.LoginId && result.LoginId !== binding.lockLoginId) {
-                    await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
-                        lockLoginId: result.LoginId,
-                    });
-                    logger.info(`用户 ${binding.userId} 登录状态已刷新，LoginId: ${result.LoginId}`);
-                }
-                else {
-                    logger.debug(`用户 ${binding.userId} 登录状态已刷新`);
-                }
-            }
-            else {
-                if (result.UserID === -2) {
-                    logger.error(`用户 ${binding.userId} 刷新登录失败：Turnstile校验失败`);
-                }
-                else {
-                    logger.error(`用户 ${binding.userId} 刷新登录失败：服务端未返回成功状态`);
-                }
-            }
-        }
-        catch (error) {
-            logger.error(`刷新用户 ${binding.userId} 登录状态失败:`, error);
-        }
-    };
+          logger.debug('插件已停止，取消登录请求')
+          return
+        }
+  
+        logger.debug(`刷新用户 ${binding.userId} (maiUid: ${maskUserId(binding.maiUid)}) 的登录状态`)
+        
+        // 重新执行登录
+        const result = await api.login(
+          binding.maiUid,
+          machineInfo.regionId,
+          machineInfo.placeId,
+          machineInfo.clientId,
+          turnstileToken,
+        )
+        
+        if (result.LoginStatus) {
+          // 更新LoginId（如果有变化）
+          if (result.LoginId && result.LoginId !== binding.lockLoginId) {
+            await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
+              lockLoginId: result.LoginId,
+            })
+            logger.info(`用户 ${binding.userId} 登录状态已刷新，LoginId: ${result.LoginId}`)
+          } else {
+            logger.debug(`用户 ${binding.userId} 登录状态已刷新`)
+          }
+        } else {
+          if (result.UserID === -2) {
+            logger.error(`用户 ${binding.userId} 刷新登录失败：Turnstile校验失败`)
+          } else {
+            logger.error(`用户 ${binding.userId} 刷新登录失败：服务端未返回成功状态`)
+          }
+        }
+      } catch (error) {
+        logger.error(`刷新用户 ${binding.userId} 登录状态失败:`, error)
+      }
+    }
+  
     /**
      * 保持锁定账号的登录状态
      * 使用并发处理和延迟对锁定的用户重新执行login
+     * @deprecated 锁定功能已在新API中移除，已注释
      */
+    /*
     const refreshLockedAccounts = async () => {
-        // 检查插件是否还在运行
-        if (!isPluginActive) {
-            logger.debug('插件已停止，取消刷新锁定账号任务');
-            return;
-        }
-        logger.debug('开始刷新锁定账号的登录状态...');
-        try {
-            // 获取所有锁定的账号
-            const lockedBindings = await ctx.database.get('maibot_bindings', {
-                isLocked: true,
-            });
-            logger.info(`找到 ${lockedBindings.length} 个锁定的账号，开始刷新登录状态（并发数: ${lockRefreshConcurrency}，延迟: ${lockRefreshDelay}ms）`);
-            if (lockedBindings.length === 0) {
-                logger.debug('没有锁定的账号需要刷新');
-                return;
-            }
-            // 使用并发处理，批次之间添加延迟
-            // refreshSingleLockedAccount 内部会检查账号是否仍然被锁定，所以这里直接处理即可
-            for (let i = 0; i < lockedBindings.length; i += lockRefreshConcurrency) {
-                // 在每批处理前检查插件状态
-                if (!isPluginActive) {
-                    logger.debug('插件已停止，中断刷新锁定账号任务');
-                    break;
-                }
-                const batch = lockedBindings.slice(i, i + lockRefreshConcurrency);
-                // 并发处理当前批次（每个任务内部会检查账号是否仍然被锁定）
-                await Promise.all(batch.map(refreshSingleLockedAccount));
-                // 如果不是最后一批，添加延迟（延迟前再次检查插件状态）
-                if (i + lockRefreshConcurrency < lockedBindings.length) {
-                    if (!isPluginActive) {
-                        logger.debug('插件已停止，中断刷新锁定账号任务');
-                        break;
-                    }
-                    await new Promise(resolve => setTimeout(resolve, lockRefreshDelay));
-                }
+      // 检查插件是否还在运行
+      if (!isPluginActive) {
+        logger.debug('插件已停止，取消刷新锁定账号任务')
+        return
+      }
+  
+      logger.debug('开始刷新锁定账号的登录状态...')
+      try {
+        // 获取所有锁定的账号
+        const lockedBindings = await ctx.database.get('maibot_bindings', {
+          isLocked: true,
+        })
+        
+        logger.info(`找到 ${lockedBindings.length} 个锁定的账号，开始刷新登录状态（并发数: ${lockRefreshConcurrency}，延迟: ${lockRefreshDelay}ms）`)
+        
+        if (lockedBindings.length === 0) {
+          logger.debug('没有锁定的账号需要刷新')
+          return
+        }
+  
+        // 使用并发处理，批次之间添加延迟
+        // refreshSingleLockedAccount 内部会检查账号是否仍然被锁定，所以这里直接处理即可
+        for (let i = 0; i < lockedBindings.length; i += lockRefreshConcurrency) {
+          // 在每批处理前检查插件状态
+          if (!isPluginActive) {
+            logger.debug('插件已停止，中断刷新锁定账号任务')
+            break
+          }
+  
+          const batch = lockedBindings.slice(i, i + lockRefreshConcurrency)
+          // 并发处理当前批次（每个任务内部会检查账号是否仍然被锁定）
+          await Promise.all(batch.map(refreshSingleLockedAccount))
+          
+          // 如果不是最后一批，添加延迟（延迟前再次检查插件状态）
+          if (i + lockRefreshConcurrency < lockedBindings.length) {
+            if (!isPluginActive) {
+              logger.debug('插件已停止，中断刷新锁定账号任务')
+              break
             }
+            await new Promise(resolve => setTimeout(resolve, lockRefreshDelay))
+          }
         }
-        catch (error) {
-            logger.error('刷新锁定账号登录状态失败:', error);
-        }
-        logger.debug('锁定账号登录状态刷新完成');
-    };
+      } catch (error) {
+        logger.error('刷新锁定账号登录状态失败:', error)
+      }
+      logger.debug('锁定账号登录状态刷新完成')
+    }
+  
     // 启动锁定账号刷新任务，每1分钟执行一次
-    const lockRefreshInterval = 60 * 1000; // 1分钟
-    logger.info(`锁定账号刷新功能已启动，每1分钟刷新一次`);
-    ctx.setInterval(refreshLockedAccounts, lockRefreshInterval);
+    const lockRefreshInterval = 60 * 1000  // 1分钟
+    logger.info(`锁定账号刷新功能已启动，每1分钟刷新一次`)
+    ctx.setInterval(refreshLockedAccounts, lockRefreshInterval)
+    
     // 立即执行一次刷新（延迟30秒，避免与首次检查冲突）
     ctx.setTimeout(() => {
-        logger.info('执行首次锁定账号刷新...');
-        refreshLockedAccounts();
-    }, 30000); // 30秒后执行首次刷新
+      logger.info('执行首次锁定账号刷新...')
+      refreshLockedAccounts()
+    }, 30000) // 30秒后执行首次刷新
+    */
     /**
      * 保护模式：自动锁定单个账号（当检测到下线时）
+     * @deprecated 保护模式功能已在新API中移除，已注释
      */
-    const autoLockAccount = async (binding) => {
-        // 检查插件是否还在运行
+    /*
+    const autoLockAccount = async (binding: UserBinding) => {
+      // 检查插件是否还在运行
+      if (!isPluginActive) {
+        logger.debug('插件已停止，跳过自动锁定检查')
+        return
+      }
+  
+      try {
+        // 再次检查账号是否仍在保护模式下且未锁定
+        const currentBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId })
+        if (currentBinding.length === 0 || !currentBinding[0].protectionMode || currentBinding[0].isLocked) {
+          logger.debug(`用户 ${binding.userId} 保护模式已关闭或账号已锁定，跳过自动锁定检查`)
+          return
+        }
+  
+        // 再次检查插件状态
         if (!isPluginActive) {
-            logger.debug('插件已停止，跳过自动锁定检查');
-            return;
-        }
-        try {
-            // 再次检查账号是否仍在保护模式下且未锁定
-            const currentBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
-            if (currentBinding.length === 0 || !currentBinding[0].protectionMode || currentBinding[0].isLocked) {
-                logger.debug(`用户 ${binding.userId} 保护模式已关闭或账号已锁定，跳过自动锁定检查`);
-                return;
-            }
-            // 再次检查插件状态
-            if (!isPluginActive) {
-                logger.debug('插件已停止，取消预览请求');
-                return;
-            }
-            logger.debug(`保护模式：检查用户 ${binding.userId} (maiUid: ${maskUserId(binding.maiUid)}) 的登录状态`);
-            // 获取当前登录状态
-            const preview = await api.preview(binding.maiUid);
-            const currentLoginStatus = parseLoginStatus(preview.IsLogin);
-            logger.debug(`用户 ${binding.userId} 当前登录状态: ${currentLoginStatus}`);
-            // 如果账号已下线，尝试自动锁定
-            if (!currentLoginStatus) {
-                logger.info(`保护模式：检测到用户 ${binding.userId} 账号已下线，尝试自动锁定`);
-                // 再次确认账号状态和插件状态
-                const verifyBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
-                if (verifyBinding.length === 0 || !verifyBinding[0].protectionMode || verifyBinding[0].isLocked) {
-                    logger.debug(`用户 ${binding.userId} 保护模式已关闭或账号已锁定，取消自动锁定`);
-                    return;
-                }
-                if (!isPluginActive) {
-                    logger.debug('插件已停止，取消自动锁定请求');
-                    return;
-                }
-                // 执行锁定
-                const result = await api.login(binding.maiUid, machineInfo.regionId, machineInfo.placeId, machineInfo.clientId, turnstileToken);
-                if (result.LoginStatus) {
-                    // 锁定成功，更新数据库
-                    await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
-                        isLocked: true,
-                        lockTime: new Date(),
-                        lockLoginId: result.LoginId,
-                    });
-                    logger.info(`保护模式：用户 ${binding.userId} 账号已自动锁定成功，LoginId: ${result.LoginId}`);
-                    // 发送@用户通知
-                    const finalBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
-                    if (finalBinding.length > 0 && finalBinding[0].guildId && finalBinding[0].channelId) {
-                        try {
-                            // 获取玩家名
-                            // 获取玩家名
-                            const playerName = preview.UserName || binding.userName || '玩家';
-                            const mention = `<at id="${binding.userId}"/>`;
-                            // 使用配置的消息模板
-                            const message = protectionLockMessage
-                                .replace(/{playerid}/g, playerName)
-                                .replace(/{at}/g, mention);
-                            // 尝试使用第一个可用的bot发送消息
-                            let sent = false;
-                            for (const bot of ctx.bots) {
-                                try {
-                                    await bot.sendMessage(finalBinding[0].channelId, message, finalBinding[0].guildId);
-                                    logger.info(`✅ 已发送保护模式锁定成功通知给用户 ${binding.userId} (${playerName})`);
-                                    sent = true;
-                                    break; // 成功发送后退出循环
-                                }
-                                catch (error) {
-                                    logger.warn(`bot ${bot.selfId} 发送保护模式通知失败:`, error);
-                                    continue;
-                                }
-                            }
-                            if (!sent) {
-                                logger.error(`❌ 所有bot都无法发送保护模式通知给用户 ${binding.userId}`);
-                            }
-                        }
-                        catch (error) {
-                            logger.error(`发送保护模式通知失败:`, error);
-                        }
-                    }
-                }
-                else {
-                    logger.warn(`保护模式：用户 ${binding.userId} 自动锁定失败，将在下次检查时重试`);
-                    if (result.UserID === -2) {
-                        logger.error(`保护模式：用户 ${binding.userId} 自动锁定失败：Turnstile校验失败`);
-                    }
-                }
-            }
-            else {
-                logger.debug(`保护模式：用户 ${binding.userId} 账号仍在线上，无需锁定`);
-            }
-        }
-        catch (error) {
-            logger.error(`保护模式：检查用户 ${binding.userId} 状态失败:`, error);
-        }
-    };
+          logger.debug('插件已停止，取消预览请求')
+          return
+        }
+  
+        logger.debug(`保护模式：检查用户 ${binding.userId} (maiUid: ${maskUserId(binding.maiUid)}) 的登录状态`)
+        
+        // 获取当前登录状态
+        // 使用新API获取用户信息（需要qr_text）
+        if (!binding.qrCode) {
+          logger.warn(`用户 ${binding.userId} 没有qrCode，跳过状态检查`)
+          return
+        }
+        const preview = await api.getPreview(machineInfo.clientId, binding.qrCode)
+        const currentLoginStatus = preview.IsLogin === true
+        logger.debug(`用户 ${binding.userId} 当前登录状态: ${currentLoginStatus}`)
+  
+        // 如果账号已下线，尝试自动锁定
+        if (!currentLoginStatus) {
+          logger.info(`保护模式：检测到用户 ${binding.userId} 账号已下线，尝试自动锁定`)
+          
+          // 再次确认账号状态和插件状态
+          const verifyBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId })
+          if (verifyBinding.length === 0 || !verifyBinding[0].protectionMode || verifyBinding[0].isLocked) {
+            logger.debug(`用户 ${binding.userId} 保护模式已关闭或账号已锁定，取消自动锁定`)
+            return
+          }
+  
+          if (!isPluginActive) {
+            logger.debug('插件已停止，取消自动锁定请求')
+            return
+          }
+  
+          // 执行锁定
+          const result = await api.login(
+            binding.maiUid,
+            machineInfo.regionId,
+            machineInfo.placeId,
+            machineInfo.clientId,
+            turnstileToken,
+          )
+  
+          if (result.LoginStatus) {
+            // 锁定成功，更新数据库
+            await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
+              isLocked: true,
+              lockTime: new Date(),
+              lockLoginId: result.LoginId,
+            })
+            logger.info(`保护模式：用户 ${binding.userId} 账号已自动锁定成功，LoginId: ${result.LoginId}`)
+            
+            // 发送@用户通知
+            const finalBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId })
+            if (finalBinding.length > 0 && finalBinding[0].guildId && finalBinding[0].channelId) {
+              try {
+                // 获取玩家名
+                // 获取玩家名
+                const playerName = preview.UserName || binding.userName || '玩家'
+                const mention = `<at id="${binding.userId}"/>`
+                // 使用配置的消息模板
+                const message = protectionLockMessage
+                  .replace(/{playerid}/g, playerName)
+                  .replace(/{at}/g, mention)
+                
+                // 尝试使用第一个可用的bot发送消息
+                let sent = false
+                for (const bot of ctx.bots) {
+                  try {
+                    await bot.sendMessage(finalBinding[0].channelId, message, finalBinding[0].guildId)
+                    logger.info(`✅ 已发送保护模式锁定成功通知给用户 ${binding.userId} (${playerName})`)
+                    sent = true
+                    break // 成功发送后退出循环
+                  } catch (error) {
+                    logger.warn(`bot ${bot.selfId} 发送保护模式通知失败:`, error)
+                    continue
+                  }
+                }
+                
+                if (!sent) {
+                  logger.error(`❌ 所有bot都无法发送保护模式通知给用户 ${binding.userId}`)
+                }
+              } catch (error) {
+                logger.error(`发送保护模式通知失败:`, error)
+              }
+            }
+          } else {
+            logger.warn(`保护模式：用户 ${binding.userId} 自动锁定失败，将在下次检查时重试`)
+            if (result.UserID === -2) {
+              logger.error(`保护模式：用户 ${binding.userId} 自动锁定失败：Turnstile校验失败`)
+            }
+          }
+        } else {
+          logger.debug(`保护模式：用户 ${binding.userId} 账号仍在线上，无需锁定`)
+        }
+      } catch (error) {
+        logger.error(`保护模式：检查用户 ${binding.userId} 状态失败:`, error)
+      }
+    }
+  
     /**
      * 保护模式：检查所有启用保护模式的账号，自动锁定已下线的账号
+     * @deprecated 保护模式功能已在新API中移除，已注释
      */
+    /*
     const checkProtectionMode = async () => {
-        // 检查插件是否还在运行
-        if (!isPluginActive) {
-            logger.debug('插件已停止，取消保护模式检查任务');
-            return;
-        }
-        logger.debug('开始检查保护模式账号...');
-        try {
-            // 获取所有启用保护模式且未锁定的账号
-            const allBindings = await ctx.database.get('maibot_bindings', {});
-            logger.debug(`总共有 ${allBindings.length} 个绑定记录`);
-            // 过滤出启用保护模式且未锁定的账号
-            const bindings = allBindings.filter(b => {
-                return b.protectionMode === true && b.isLocked !== true;
-            });
-            logger.debug(`启用保护模式的账号数量: ${bindings.length}`);
-            if (bindings.length > 0) {
-                logger.debug(`启用保护模式的账号列表: ${bindings.map(b => `${b.userId}(${maskUserId(b.maiUid)})`).join(', ')}`);
-            }
-            if (bindings.length === 0) {
-                logger.debug('没有启用保护模式的账号，跳过检查');
-                return;
-            }
-            // 使用并发处理
-            logger.debug(`使用并发数 ${concurrency} 检查 ${bindings.length} 个保护模式账号`);
-            await processBatch(bindings, concurrency, autoLockAccount);
-        }
-        catch (error) {
-            logger.error('检查保护模式账号失败:', error);
-        }
-        logger.debug('保护模式检查完成');
-    };
+      // 检查插件是否还在运行
+      if (!isPluginActive) {
+        logger.debug('插件已停止，取消保护模式检查任务')
+        return
+      }
+  
+      logger.debug('开始检查保护模式账号...')
+      try {
+        // 获取所有启用保护模式且未锁定的账号
+        const allBindings = await ctx.database.get('maibot_bindings', {})
+        logger.debug(`总共有 ${allBindings.length} 个绑定记录`)
+  
+        // 过滤出启用保护模式且未锁定的账号
+        const bindings = allBindings.filter(b => {
+          return b.protectionMode === true && b.isLocked !== true
+        })
+        
+        logger.debug(`启用保护模式的账号数量: ${bindings.length}`)
+        
+        if (bindings.length > 0) {
+          logger.debug(`启用保护模式的账号列表: ${bindings.map(b => `${b.userId}(${maskUserId(b.maiUid)})`).join(', ')}`)
+        }
+        
+        if (bindings.length === 0) {
+          logger.debug('没有启用保护模式的账号，跳过检查')
+          return
+        }
+  
+        // 使用并发处理
+        logger.debug(`使用并发数 ${concurrency} 检查 ${bindings.length} 个保护模式账号`)
+        await processBatch(bindings, concurrency, autoLockAccount)
+        
+      } catch (error) {
+        logger.error('检查保护模式账号失败:', error)
+      }
+      logger.debug('保护模式检查完成')
+    }
+  
     // 启动保护模式检查定时任务，使用配置的间隔
-    const protectionCheckInterval = config.protectionCheckInterval ?? 60000; // 默认60秒
-    logger.info(`账号保护模式检查功能已启动，检查间隔: ${protectionCheckInterval}ms (${protectionCheckInterval / 1000}秒)，并发数: ${concurrency}`);
-    ctx.setInterval(checkProtectionMode, protectionCheckInterval);
+    const protectionCheckInterval = config.protectionCheckInterval ?? 60000  // 默认60秒
+    logger.info(`账号保护模式检查功能已启动，检查间隔: ${protectionCheckInterval}ms (${protectionCheckInterval / 1000}秒)，并发数: ${concurrency}`)
+    ctx.setInterval(checkProtectionMode, protectionCheckInterval)
+    
     // 立即执行一次检查（延迟35秒，避免与其他检查冲突）
     ctx.setTimeout(() => {
-        logger.info('执行首次保护模式检查...');
-        checkProtectionMode();
-    }, 35000); // 35秒后执行首次检查
+      logger.info('执行首次保护模式检查...')
+      checkProtectionMode()
+    }, 35000) // 35秒后执行首次检查
+  
     /**
      * 开关播报功能
      * 用法: /maialert [on|off]
@@ -2712,12 +3201,17 @@ function apply(ctx, config) {
             if (newState && binding.lastLoginStatus === undefined) {
                 try {
                     logger.debug(`初始化用户 ${targetUserId} 的登录状态...`);
-                    const preview = await api.preview(binding.maiUid);
-                    const loginStatus = parseLoginStatus(preview.IsLogin);
+                    // 使用新API获取用户信息（需要qr_text）
+                    if (!binding.qrCode) {
+                        logger.warn(`用户 ${targetUserId} 没有qrCode，跳过状态初始化`);
+                        return;
+                    }
+                    const preview = await api.getPreview(machineInfo.clientId, binding.qrCode);
+                    const loginStatus = preview.IsLogin === true;
                     await ctx.database.set('maibot_bindings', { userId: targetUserId }, {
                         lastLoginStatus: loginStatus,
                     });
-                    logger.info(`用户 ${targetUserId} 初始登录状态: ${loginStatus} (IsLogin原始值: "${preview.IsLogin}")`);
+                    logger.info(`用户 ${targetUserId} 初始登录状态: ${loginStatus} (IsLogin: ${preview.IsLogin})`);
                 }
                 catch (error) {
                     logger.warn(`初始化用户 ${targetUserId} 登录状态失败:`, error);
@@ -2740,164 +3234,205 @@ function apply(ctx, config) {
     /**
      * 开关账号保护模式
      * 用法: /mai保护模式 [on|off]
+     * @deprecated 保护模式功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai保护模式 [state:text] [targetUserId:text]', '开关账号保护模式（自动锁定已下线的账号）')
-        .userFields(['authority'])
-        .action(async ({ session }, state, targetUserId) => {
+      .userFields(['authority'])
+      .action(async ({ session }, state, targetUserId) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         // 检查隐藏模式
         if (hideLockAndProtection) {
-            return '❌ 该功能已禁用';
+          return '❌ 该功能已禁用'
         }
+  
         try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            const currentState = binding.protectionMode ?? false;
-            // 如果没有提供参数，显示当前状态
-            if (!state) {
-                return `当前保护模式状态: ${currentState ? '✅ 已开启' : '❌ 已关闭'}\n\n使用 /mai保护模式 on 开启\n使用 /mai保护模式 off 关闭\n\n开启后会自动锁定账号，如果锁定失败会在账号下线时自动尝试锁定`;
-            }
-            const newState = state.toLowerCase() === 'on' || state.toLowerCase() === 'true' || state === '1';
-            // 如果状态没有变化
-            if (currentState === newState) {
-                return `保护模式已经是 ${newState ? '开启' : '关闭'} 状态`;
-            }
-            logger.info(`用户 ${userId} ${newState ? '开启' : '关闭'}保护模式`);
-            if (newState) {
-                // 开启保护模式：尝试立即锁定账号
-                if (binding.isLocked) {
-                    // 如果已经锁定，直接开启保护模式
-                    await ctx.database.set('maibot_bindings', { userId }, {
-                        protectionMode: true,
-                    });
-                    return `✅ 保护模式已开启\n账号当前已锁定，保护模式将在账号解锁后生效`;
-                }
-                // 尝试锁定账号
-                await session.send('⏳ 正在尝试锁定账号，请稍候...');
-                const result = await api.login(binding.maiUid, machineInfo.regionId, machineInfo.placeId, machineInfo.clientId, turnstileToken);
-                const updateData = {
-                    protectionMode: true,
-                };
-                if (result.LoginStatus) {
-                    // 锁定成功
-                    updateData.isLocked = true;
-                    updateData.lockTime = new Date();
-                    updateData.lockLoginId = result.LoginId;
-                    // 如果之前开启了推送，锁定时自动关闭
-                    if (binding.alertEnabled === true) {
-                        updateData.alertEnabled = false;
-                        logger.info(`用户 ${userId} 保护模式锁定账号，已自动关闭 maialert 推送`);
-                    }
-                    await ctx.database.set('maibot_bindings', { userId }, updateData);
-                    return `✅ 保护模式已开启\n账号已成功锁定，将保持登录状态防止他人登录`;
-                }
-                else {
-                    // 锁定失败，但仍开启保护模式，系统会在账号下线时自动尝试锁定
-                    await ctx.database.set('maibot_bindings', { userId }, updateData);
-                    let message = `✅ 保护模式已开启\n⚠️ 当前无法锁定账号（可能账号正在被使用或者挂哥上号）\n系统将定期检查账号状态，当检测到账号下线时会自动尝试锁定，防止一直小黑屋！\n`;
-                    if (result.UserID === -2) {
-                        message += `\n错误信息：Turnstile校验失败`;
-                    }
-                    else {
-                        message += `\n错误信息：服务端未返回成功状态`;
-                    }
-                    return message;
-                }
-            }
-            else {
-                // 关闭保护模式
-                await ctx.database.set('maibot_bindings', { userId }, {
-                    protectionMode: false,
-                });
-                return `✅ 保护模式已关闭\n已停止自动锁定功能`;
-            }
-        }
-        catch (error) {
-            logger.error('开关保护模式失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            return `❌ 操作失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 获取目标用户绑定
+          const { binding, isProxy, error } = await getTargetBinding(session, targetUserId)
+          if (error || !binding) {
+            return error || '❌ 获取用户绑定失败'
+          }
+  
+          const userId = binding.userId
+          const currentState = binding.protectionMode ?? false
+  
+          // 如果没有提供参数，显示当前状态
+          if (!state) {
+            return `当前保护模式状态: ${currentState ? '✅ 已开启' : '❌ 已关闭'}\n\n使用 /mai保护模式 on 开启\n使用 /mai保护模式 off 关闭\n\n开启后会自动锁定账号，如果锁定失败会在账号下线时自动尝试锁定`
+          }
+  
+          const newState = state.toLowerCase() === 'on' || state.toLowerCase() === 'true' || state === '1'
+  
+          // 如果状态没有变化
+          if (currentState === newState) {
+            return `保护模式已经是 ${newState ? '开启' : '关闭'} 状态`
+          }
+  
+          logger.info(`用户 ${userId} ${newState ? '开启' : '关闭'}保护模式`)
+  
+          if (newState) {
+            // 开启保护模式：尝试立即锁定账号
+            if (binding.isLocked) {
+              // 如果已经锁定，直接开启保护模式
+              await ctx.database.set('maibot_bindings', { userId }, {
+                protectionMode: true,
+              })
+              return `✅ 保护模式已开启\n账号当前已锁定，保护模式将在账号解锁后生效`
+            }
+  
+            // 尝试锁定账号
+            await session.send('⏳ 正在尝试锁定账号，请稍候...')
+  
+            const result = await api.login(
+              binding.maiUid,
+              machineInfo.regionId,
+              machineInfo.placeId,
+              machineInfo.clientId,
+              turnstileToken,
+            )
+  
+            const updateData: any = {
+              protectionMode: true,
+            }
+  
+            if (result.LoginStatus) {
+              // 锁定成功
+              updateData.isLocked = true
+              updateData.lockTime = new Date()
+              updateData.lockLoginId = result.LoginId
+              
+              // 如果之前开启了推送，锁定时自动关闭
+              if (binding.alertEnabled === true) {
+                updateData.alertEnabled = false
+                logger.info(`用户 ${userId} 保护模式锁定账号，已自动关闭 maialert 推送`)
+              }
+  
+              await ctx.database.set('maibot_bindings', { userId }, updateData)
+  
+              return `✅ 保护模式已开启\n账号已成功锁定，将保持登录状态防止他人登录`
+            } else {
+              // 锁定失败，但仍开启保护模式，系统会在账号下线时自动尝试锁定
+              await ctx.database.set('maibot_bindings', { userId }, updateData)
+  
+              let message = `✅ 保护模式已开启\n⚠️ 当前无法锁定账号（可能账号正在被使用或者挂哥上号）\n系统将定期检查账号状态，当检测到账号下线时会自动尝试锁定，防止一直小黑屋！\n`
+              
+              if (result.UserID === -2) {
+                message += `\n错误信息：Turnstile校验失败`
+              } else {
+                message += `\n错误信息：服务端未返回成功状态`
+              }
+  
+              return message
+            }
+          } else {
+            // 关闭保护模式
+            await ctx.database.set('maibot_bindings', { userId }, {
+              protectionMode: false,
+            })
+            return `✅ 保护模式已关闭\n已停止自动锁定功能`
+          }
+        } catch (error: any) {
+          logger.error('开关保护模式失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          return `❌ 操作失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+    */
     /**
      * 管理员一键关闭所有人的锁定模式和保护模式
      * 用法: /mai管理员关闭所有锁定和保护
+     * @deprecated 锁定和保护模式功能已在新API中移除，已注释
      */
+    /*
     ctx.command('mai管理员关闭所有锁定和保护', '管理员一键关闭所有人的锁定模式和保护模式（需要auth等级3以上）')
-        .userFields(['authority'])
-        .option('bypass', '-bypass  绕过确认')
-        .action(async ({ session, options }) => {
+      .userFields(['authority'])
+      .option('bypass', '-bypass  绕过确认')
+      .action(async ({ session, options }) => {
         if (!session) {
-            return '❌ 无法获取会话信息';
+          return '❌ 无法获取会话信息'
         }
+  
         // 检查权限
         if ((session.user?.authority ?? 0) < 3) {
-            return '❌ 权限不足，需要auth等级3以上才能执行此操作';
+          return '❌ 权限不足，需要auth等级3以上才能执行此操作'
         }
+  
         try {
-            // 确认操作（如果未使用 -bypass）
-            if (!options?.bypass) {
-                const confirm = await promptYesLocal(session, '⚠️ 即将关闭所有用户的锁定模式和保护模式\n此操作将影响所有已绑定账号的用户\n确认继续？');
-                if (!confirm) {
-                    return '操作已取消';
-                }
-            }
-            await session.send('⏳ 正在处理，请稍候...');
-            // 获取所有绑定记录
-            const allBindings = await ctx.database.get('maibot_bindings', {});
-            // 统计需要更新的用户数量
-            let lockedCount = 0;
-            let protectionCount = 0;
-            let totalUpdated = 0;
-            // 遍历所有绑定记录，更新锁定模式和保护模式
-            for (const binding of allBindings) {
-                const updateData = {};
-                let needsUpdate = false;
-                // 如果用户开启了锁定模式，关闭它
-                if (binding.isLocked === true) {
-                    updateData.isLocked = false;
-                    updateData.lockTime = null;
-                    updateData.lockLoginId = null;
-                    lockedCount++;
-                    needsUpdate = true;
-                }
-                // 如果用户开启了保护模式，关闭它
-                if (binding.protectionMode === true) {
-                    updateData.protectionMode = false;
-                    protectionCount++;
-                    needsUpdate = true;
-                }
-                // 如果有需要更新的字段，执行更新
-                if (needsUpdate) {
-                    await ctx.database.set('maibot_bindings', { userId: binding.userId }, updateData);
-                    totalUpdated++;
-                }
-            }
-            logger.info(`管理员 ${session.userId} 执行了一键关闭操作，更新了 ${totalUpdated} 个用户（锁定: ${lockedCount}，保护模式: ${protectionCount}）`);
-            let resultMessage = `✅ 操作完成\n\n`;
-            resultMessage += `已更新用户数: ${totalUpdated}\n`;
-            resultMessage += `关闭锁定模式: ${lockedCount} 个用户\n`;
-            resultMessage += `关闭保护模式: ${protectionCount} 个用户`;
-            if (totalUpdated === 0) {
-                resultMessage = `ℹ️ 没有需要更新的用户\n所有用户都未开启锁定模式和保护模式`;
-            }
-            return resultMessage;
-        }
-        catch (error) {
-            logger.error('管理员一键关闭操作失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
-            }
-            return `❌ 操作失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
-    });
+          // 确认操作（如果未使用 -bypass）
+          if (!options?.bypass) {
+            const confirm = await promptYesLocal(
+              session,
+              '⚠️ 即将关闭所有用户的锁定模式和保护模式\n此操作将影响所有已绑定账号的用户\n确认继续？'
+            )
+            if (!confirm) {
+              return '操作已取消'
+            }
+          }
+  
+          await session.send('⏳ 正在处理，请稍候...')
+  
+          // 获取所有绑定记录
+          const allBindings = await ctx.database.get('maibot_bindings', {})
+          
+          // 统计需要更新的用户数量
+          let lockedCount = 0
+          let protectionCount = 0
+          let totalUpdated = 0
+  
+          // 遍历所有绑定记录，更新锁定模式和保护模式
+          for (const binding of allBindings) {
+            const updateData: any = {}
+            let needsUpdate = false
+  
+            // 如果用户开启了锁定模式，关闭它
+            if (binding.isLocked === true) {
+              updateData.isLocked = false
+              updateData.lockTime = null
+              updateData.lockLoginId = null
+              lockedCount++
+              needsUpdate = true
+            }
+  
+            // 如果用户开启了保护模式，关闭它
+            if (binding.protectionMode === true) {
+              updateData.protectionMode = false
+              protectionCount++
+              needsUpdate = true
+            }
+  
+            // 如果有需要更新的字段，执行更新
+            if (needsUpdate) {
+              await ctx.database.set('maibot_bindings', { userId: binding.userId }, updateData)
+              totalUpdated++
+            }
+          }
+  
+          logger.info(`管理员 ${session.userId} 执行了一键关闭操作，更新了 ${totalUpdated} 个用户（锁定: ${lockedCount}，保护模式: ${protectionCount}）`)
+  
+          let resultMessage = `✅ 操作完成\n\n`
+          resultMessage += `已更新用户数: ${totalUpdated}\n`
+          resultMessage += `关闭锁定模式: ${lockedCount} 个用户\n`
+          resultMessage += `关闭保护模式: ${protectionCount} 个用户`
+  
+          if (totalUpdated === 0) {
+            resultMessage = `ℹ️ 没有需要更新的用户\n所有用户都未开启锁定模式和保护模式`
+          }
+  
+          return resultMessage
+        } catch (error: any) {
+          logger.error('管理员一键关闭操作失败:', error)
+          if (maintenanceMode) {
+            return maintenanceMessage
+          }
+          return `❌ 操作失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        }
+      })
+  
     /**
      * 管理员关闭/开启登录播报功能（全局开关）
      * 用法: /mai管理员关闭登录播报 [on|off]