koishi-plugin-maibot 1.7.30 → 1.7.32

package/lib/index.js

@@ -674,13 +674,26 @@ async function waitForUserReply(session, ctx, timeout) {
 }
 /**
  * 交互式获取二维码文本（qr_text）
- * 废弃旧的uid策略，每次都需要新的二维码
- * 不再使用binding.qrCode缓存，每次操作都要求用户提供新二维码
+ * 支持10分钟内使用上次输入的SGID缓存
+ * 如果缓存存在且有效，直接使用；否则提示用户输入
  */
-async function getQrText(session, ctx, api, binding, config, timeout = 60000, promptMessage) {
+async function getQrText(session, ctx, api, binding, config, timeout = 60000, promptMessage, useCache = true // 是否使用缓存（默认启用）
+) {
     const logger = ctx.logger('maibot');
-    // 废弃旧的uid策略，每次都需要新的二维码
-    // 不再使用binding.qrCode缓存，直接提示用户输入
+    // 如果启用缓存且binding存在，检查是否有10分钟内的SGID缓存
+    if (useCache && binding && binding.lastQrCode && binding.lastQrCodeTime) {
+        const cacheAge = Date.now() - new Date(binding.lastQrCodeTime).getTime();
+        const cacheValidDuration = 10 * 60 * 1000; // 10分钟
+        if (cacheAge < cacheValidDuration && binding.lastQrCode.startsWith('SGWCMAID')) {
+            logger.info(`使用缓存的SGID（${Math.floor(cacheAge / 1000)}秒前输入）`);
+            // 直接返回缓存的SGID，不验证（让调用方验证，如果失败再提示输入）
+            return { qrText: binding.lastQrCode, fromCache: true };
+        }
+        else {
+            logger.debug(`缓存已过期（${Math.floor(cacheAge / 1000)}秒前输入，超过10分钟）`);
+        }
+    }
+    // 没有有效缓存，提示用户输入
     const actualTimeout = timeout;
     const message = promptMessage || `请在${actualTimeout / 1000}秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址`;
     try {
@@ -749,12 +762,14 @@ async function getQrText(session, ctx, api, binding, config, timeout = 60000, pr
                 await session.send('❌ 无效或过期的二维码，请重新发送');
                 return { qrText: '', error: '无效或过期的二维码' };
             }
-            // 如果binding存在，更新数据库中的qrCode（仅用于记录，不再用于缓存）
+            // 如果binding存在，更新数据库中的qrCode和缓存
             if (binding) {
                 await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
                     qrCode: qrText,
+                    lastQrCode: qrText, // 更新缓存
+                    lastQrCodeTime: new Date(), // 更新时间戳
                 });
-                logger.info(`已更新用户 ${binding.userId} 的qrCode（仅用于记录）`);
+                logger.info(`已更新用户 ${binding.userId} 的qrCode和缓存`);
             }
             return { qrText: qrText };
         }
@@ -907,6 +922,8 @@ async function promptForRebind(session, ctx, api, binding, config, timeout = 600
             bindTime: new Date(),
             userName,
             rating,
+            lastQrCode: qrCode, // 保存为缓存
+            lastQrCodeTime: new Date(), // 保存时间戳
         });
         // 发送成功反馈
         await session.send(`✅ 重新绑定成功！${userName ? `\n用户名: ${userName}` : ''}${rating ? `\nRating: ${rating}` : ''}\n\n⚠️ 为了确保账户安全，请手动撤回群内包含SGID的消息`);
@@ -1670,6 +1687,8 @@ function apply(ctx, config) {
                 bindTime: new Date(),
                 userName,
                 rating,
+                lastQrCode: qrCode, // 保存为缓存
+                lastQrCodeTime: new Date(), // 保存时间戳
             });
             return `✅ 绑定成功！\n` +
                 (userName ? `用户名: ${userName}\n` : '') +
@@ -1748,9 +1767,11 @@ function apply(ctx, config) {
                 `绑定时间: ${new Date(binding.bindTime).toLocaleString('zh-CN')}\n` +
                 `🚨 /maialert查看账号提醒状态\n`;
             // 尝试获取最新状态并更新数据库（需要新二维码）
+            let qrTextResultForCharge = null;
             try {
                 // 废弃旧的uid策略，每次都需要新的二维码
                 const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout, '请在60秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址以查询账号状态');
+                qrTextResultForCharge = qrTextResult;
                 if (qrTextResult.error) {
                     statusInfo += `\n⚠️ 无法获取最新状态：${qrTextResult.error}`;
                 }
@@ -1852,9 +1873,70 @@ function apply(ctx, config) {
                     statusInfo += `\n\n🔒 锁定状态: 未锁定\n使用 /mai锁定 可以锁定账号（防止他人登录）`;
                 }
             }
-            // 显示票券信息
-            // @deprecated getCharge功能已在新API中移除，已注释
-            statusInfo += `\n\n🎫 票券情况: 此功能已在新API中移除`;
+            // 显示票券信息（使用新的getCharge API）
+            try {
+                if (qrTextResultForCharge && !qrTextResultForCharge.error) {
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    const chargeResult = await api.getCharge(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResultForCharge.qrText);
+                    if (chargeResult.ChargeStatus && chargeResult.userChargeList) {
+                        const now = new Date();
+                        const validTickets = [];
+                        const expiredTickets = [];
+                        for (const ticket of chargeResult.userChargeList) {
+                            const validDate = new Date(ticket.validDate);
+                            if (validDate > now) {
+                                validTickets.push(ticket);
+                            }
+                            else {
+                                expiredTickets.push(ticket);
+                            }
+                        }
+                        // 显示有效票券
+                        if (validTickets.length > 0 || (options?.expired && expiredTickets.length > 0)) {
+                            statusInfo += `\n\n🎫 票券情况：`;
+                            if (validTickets.length > 0) {
+                                statusInfo += `\n有效票券：`;
+                                for (const ticket of validTickets) {
+                                    const ticketName = getTicketName(ticket.chargeId);
+                                    const validDateStr = new Date(ticket.validDate).toLocaleString('zh-CN');
+                                    statusInfo += `\n  ${ticketName}: ${ticket.stock} 张（有效期至 ${validDateStr}）`;
+                                }
+                            }
+                            // 如果使用 --expired 选项，显示过期票券
+                            if (options?.expired && expiredTickets.length > 0) {
+                                statusInfo += `\n过期票券：`;
+                                for (const ticket of expiredTickets) {
+                                    const ticketName = getTicketName(ticket.chargeId);
+                                    const validDateStr = new Date(ticket.validDate).toLocaleString('zh-CN');
+                                    statusInfo += `\n  ${ticketName}: ${ticket.stock} 张（已过期，过期时间 ${validDateStr}）`;
+                                }
+                            }
+                            else if (expiredTickets.length > 0) {
+                                statusInfo += `\n（还有 ${expiredTickets.length} 种过期票券，使用 --expired 查看）`;
+                            }
+                            // 显示免费票券
+                            if (chargeResult.userFreeChargeList && chargeResult.userFreeChargeList.length > 0) {
+                                statusInfo += `\n免费票券：`;
+                                for (const freeTicket of chargeResult.userFreeChargeList) {
+                                    const ticketName = getTicketName(freeTicket.chargeId);
+                                    statusInfo += `\n  ${ticketName}: ${freeTicket.stock} 张`;
+                                }
+                            }
+                        }
+                        else {
+                            statusInfo += `\n\n🎫 票券情况: 暂无有效票券`;
+                        }
+                    }
+                    else {
+                        statusInfo += `\n\n🎫 票券情况: 获取失败（${chargeResult.ChargeStatus === false ? 'API返回失败' : '数据格式错误'}）`;
+                    }
+                }
+            }
+            catch (error) {
+                logger.warn('获取票券信息失败:', error);
+                statusInfo += `\n\n🎫 票券情况: 获取失败（${error?.message || '未知错误'}）`;
+            }
             return statusInfo;
         }
         catch (error) {
@@ -2285,19 +2367,24 @@ function apply(ctx, config) {
             const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
             // 确认操作（如果未使用 -bypass）
             if (!options?.bypass) {
-                const baseTip = `⚠️ 即将发放 ${multiple} 倍票${proxyTip}`;
-                const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
-                if (!confirmFirst) {
-                    return '操作已取消（第一次确认未通过）';
-                }
-                const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
-                if (!confirmSecond) {
-                    return '操作已取消（第二次确认未通过）';
+                if (multiple >= 4) {
+                    // 4-6倍：提示失败风险并二次确认
+                    const baseTip = `⚠️ 即将发放 ${multiple} 倍票${proxyTip}\n\n⚠️ 警告：4倍及以上票券极有可能失败，请谨慎操作！`;
+                    const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
+                    if (!confirmFirst) {
+                        return '操作已取消（第一次确认未通过）';
+                    }
+                    const confirmSecond = await promptYesLocal(session, `二次确认：${multiple}倍票券失败风险极高，确定要继续吗？\n若理解风险，请再次输入 Y 执行`);
+                    if (!confirmSecond) {
+                        return '操作已取消（第二次确认未通过）';
+                    }
                 }
-                if (multiple >= 3) {
-                    const confirmThird = await promptYesLocal(session, '第三次确认：3倍及以上票券风险更高，确定继续？');
-                    if (!confirmThird) {
-                        return '操作已取消（第三次确认未通过）';
+                else {
+                    // 2-3倍：一次确认
+                    const baseTip = `⚠️ 即将发放 ${multiple} 倍票${proxyTip}`;
+                    const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎\n确认继续？`);
+                    if (!confirmFirst) {
+                        return '操作已取消（确认未通过）';
                     }
                 }
             }
@@ -2332,34 +2419,73 @@ function apply(ctx, config) {
             await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
             // 使用新API获取功能票（需要qr_text）
             let ticketResult;
+            let usedCache = qrTextResult.fromCache === true;
             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);
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
                     if (retryQrText.error) {
-                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
                     }
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
                     ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
                 }
                 else {
-                    throw 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}`;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        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 `✅ 重新绑定成功！请重新执行发票操作。`;
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache && (!ticketResult.QrStatus || ticketResult.LoginStatus === false)) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
                     }
-                    return `❌ 发放功能票失败：服务器返回未成功\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+                    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 '❌ 发票失败：服务器返回未成功，请确认是否已在短时间内多次执行发票指令或稍后再试或点击获取二维码刷新账号后再试。';
+                    }
+                }
+                else {
+                    // 如果返回失败，可能需要重新绑定
+                    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 '❌ 发票失败：服务器返回未成功，请确认是否已在短时间内多次执行发票指令或稍后再试或点击获取二维码刷新账号后再试。';
             }
             return `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
         }
@@ -2561,41 +2687,76 @@ function apply(ctx, config) {
             await waitForQueue(session);
             // 上传B50（使用新API，需要qr_text）
             let result;
+            let usedCache = qrTextResult.fromCache === true;
             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);
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
                     if (retryQrText.error) {
-                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
                     }
                     // 在调用API前加入队列
                     await waitForQueue(session);
                     result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
                 }
                 else {
-                    throw 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}`;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        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任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache && (result.msg?.includes('二维码') || result.msg?.includes('qr_text') || result.msg?.includes('无效'))) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                    if (retryQrText.error) {
+                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                        return `❌ 上传失败：${result.msg || '未知错误'}\n获取新二维码失败：${retryQrText.error}${taskIdInfo}`;
+                    }
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
+                    if (!result.UploadStatus) {
+                        if (result.msg === '该账号下存在未完成的任务') {
+                            return '⚠️ 当前账号已有未完成的水鱼B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                        }
+                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                        return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
+                    }
                 }
-                // 如果返回失败，可能需要重新绑定
-                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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                else {
+                    if (result.msg === '该账号下存在未完成的任务') {
+                        return '⚠️ 当前账号已有未完成的水鱼B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                    }
+                    // 如果返回失败，可能需要重新绑定
+                    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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                        }
+                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                        return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
                     }
                     const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
-                    return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
+                    return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
                 }
-                const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
-                return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
             }
             scheduleB50Notification(session, result.task_id);
             return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
@@ -2707,7 +2868,20 @@ function apply(ctx, config) {
             const fishAbort = await (async () => {
                 try {
                     await waitForQueue(session);
-                    const fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, fishToken);
+                    let fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, fishToken);
+                    // 如果使用了缓存且失败，尝试重新获取SGID
+                    if (qrTextResult.fromCache && !fishResult.UploadStatus && (fishResult.msg?.includes('二维码') || fishResult.msg?.includes('qr_text') || fishResult.msg?.includes('无效'))) {
+                        logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                        const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                        if (retryQrText.error) {
+                            const taskIdInfo = fishResult.task_id ? `\n任务ID: ${fishResult.task_id}` : '';
+                            results.push(`🐟 水鱼: ❌ 上传失败：${fishResult.msg || '未知错误'}\n获取新二维码失败：${retryQrText.error}${taskIdInfo}`);
+                            return null;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, fishToken);
+                    }
                     if (!fishResult.UploadStatus) {
                         if (fishResult.msg === '该账号下存在未完成的任务') {
                             results.push('🐟 水鱼: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
@@ -2730,20 +2904,64 @@ function apply(ctx, config) {
                     return null;
                 }
                 catch (error) {
-                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                        return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
-                    }
-                    if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
-                        results.push('🐟 水鱼: ❌ 上传超时，请稍后再试一次。');
-                        return null;
+                    // 如果使用了缓存且失败，尝试重新获取SGID
+                    if (qrTextResult.fromCache) {
+                        logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                        const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                        if (retryQrText.error) {
+                            results.push(`🐟 水鱼: ❌ 获取二维码失败：${retryQrText.error}`);
+                            return null;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        try {
+                            const fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, fishToken);
+                            if (!fishResult.UploadStatus) {
+                                if (fishResult.msg === '该账号下存在未完成的任务') {
+                                    results.push('🐟 水鱼: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
+                                    return null;
+                                }
+                                const taskIdInfo = fishResult.task_id ? `\n任务ID: ${fishResult.task_id}` : '';
+                                results.push(`🐟 水鱼: ❌ 上传失败：${fishResult.msg || '未知错误'}${taskIdInfo}`);
+                                return null;
+                            }
+                            scheduleB50Notification(session, fishResult.task_id);
+                            results.push(`🐟 水鱼: ✅ B50任务已提交！\n任务ID: ${fishResult.task_id}\n请耐心等待任务完成，预计1-10分钟`);
+                            return null;
+                        }
+                        catch (retryError) {
+                            const failureResult = await handleApiFailure(session, ctx, api, binding, config, retryError, rebindTimeout);
+                            if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                                return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
+                            }
+                            if (retryError?.code === 'ECONNABORTED' || String(retryError?.message || '').includes('timeout')) {
+                                results.push('🐟 水鱼: ❌ 上传超时，请稍后再试一次。');
+                                return null;
+                            }
+                            if (retryError?.response) {
+                                results.push(`🐟 水鱼: ❌ API请求失败: ${retryError.response.status} ${retryError.response.statusText}`);
+                                return null;
+                            }
+                            results.push(`🐟 水鱼: ❌ 上传失败: ${retryError?.message || '未知错误'}`);
+                            return null;
+                        }
                     }
-                    if (error?.response) {
-                        results.push(`🐟 水鱼: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`);
+                    else {
+                        const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                        if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                            return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
+                        }
+                        if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
+                            results.push('🐟 水鱼: ❌ 上传超时，请稍后再试一次。');
+                            return null;
+                        }
+                        if (error?.response) {
+                            results.push(`🐟 水鱼: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`);
+                            return null;
+                        }
+                        results.push(`🐟 水鱼: ❌ 上传失败: ${error?.message || '未知错误'}`);
                         return null;
                     }
-                    results.push(`🐟 水鱼: ❌ 上传失败: ${error?.message || '未知错误'}`);
-                    return null;
                 }
             })();
             if (fishAbort) {
@@ -2753,7 +2971,20 @@ function apply(ctx, config) {
             const lxnsAbort = await (async () => {
                 try {
                     await waitForQueue(session);
-                    const lxResult = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
+                    let lxResult = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
+                    // 如果使用了缓存且失败，尝试重新获取SGID
+                    if (qrTextResult.fromCache && !lxResult.UploadStatus && (lxResult.msg?.includes('二维码') || lxResult.msg?.includes('qr_text') || lxResult.msg?.includes('无效'))) {
+                        logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                        const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                        if (retryQrText.error) {
+                            const taskIdInfo = lxResult.task_id ? `\n任务ID: ${lxResult.task_id}` : '';
+                            results.push(`❄️ 落雪: ❌ 上传失败：${lxResult.msg || '未知错误'}\n获取新二维码失败：${retryQrText.error}${taskIdInfo}`);
+                            return null;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        lxResult = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                    }
                     if (!lxResult.UploadStatus) {
                         if (lxResult.msg === '该账号下存在未完成的任务') {
                             results.push('❄️ 落雪: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
@@ -2776,20 +3007,64 @@ function apply(ctx, config) {
                     return null;
                 }
                 catch (error) {
-                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                        return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
-                    }
-                    if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
-                        results.push('❄️ 落雪: ❌ 上传超时，请稍后再试一次。');
-                        return null;
+                    // 如果使用了缓存且失败，尝试重新获取SGID
+                    if (qrTextResult.fromCache) {
+                        logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                        const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                        if (retryQrText.error) {
+                            results.push(`❄️ 落雪: ❌ 获取二维码失败：${retryQrText.error}`);
+                            return null;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        try {
+                            const lxResult = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                            if (!lxResult.UploadStatus) {
+                                if (lxResult.msg === '该账号下存在未完成的任务') {
+                                    results.push('❄️ 落雪: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
+                                    return null;
+                                }
+                                const taskIdInfo = lxResult.task_id ? `\n任务ID: ${lxResult.task_id}` : '';
+                                results.push(`❄️ 落雪: ❌ 上传失败：${lxResult.msg || '未知错误'}${taskIdInfo}`);
+                                return null;
+                            }
+                            scheduleLxB50Notification(session, lxResult.task_id);
+                            results.push(`❄️ 落雪: ✅ B50任务已提交！\n任务ID: ${lxResult.task_id}\n请耐心等待任务完成，预计1-10分钟`);
+                            return null;
+                        }
+                        catch (retryError) {
+                            const failureResult = await handleApiFailure(session, ctx, api, binding, config, retryError, rebindTimeout);
+                            if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                                return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
+                            }
+                            if (retryError?.code === 'ECONNABORTED' || String(retryError?.message || '').includes('timeout')) {
+                                results.push('❄️ 落雪: ❌ 上传超时，请稍后再试一次。');
+                                return null;
+                            }
+                            if (retryError?.response) {
+                                results.push(`❄️ 落雪: ❌ API请求失败: ${retryError.response.status} ${retryError.response.statusText}`);
+                                return null;
+                            }
+                            results.push(`❄️ 落雪: ❌ 上传失败: ${retryError?.message || '未知错误'}`);
+                            return null;
+                        }
                     }
-                    if (error?.response) {
-                        results.push(`❄️ 落雪: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`);
+                    else {
+                        const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                        if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                            return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
+                        }
+                        if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
+                            results.push('❄️ 落雪: ❌ 上传超时，请稍后再试一次。');
+                            return null;
+                        }
+                        if (error?.response) {
+                            results.push(`❄️ 落雪: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`);
+                            return null;
+                        }
+                        results.push(`❄️ 落雪: ❌ 上传失败: ${error?.message || '未知错误'}`);
                         return null;
                     }
-                    results.push(`❄️ 落雪: ❌ 上传失败: ${error?.message || '未知错误'}`);
-                    return null;
                 }
             })();
             if (lxnsAbort) {
@@ -2925,90 +3200,158 @@ 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 '❌ 无法获取会话信息';
+        }
+        // 检查白名单
+        const whitelistCheck = checkWhitelist(session, config);
+        if (!whitelistCheck.allowed) {
+            return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-  
         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: 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}`
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            const proxyTip = isProxy ? `（代操作用户 ${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 promptSession = await waitForUserReply(session, ctx, 60000);
+            const itemIdInput = promptSession?.content?.trim() || '';
+            if (!itemIdInput || itemIdInput === '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)} 发放收藏品${proxyTip}\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`);
+                if (!confirm) {
+                    return '操作已取消';
+                }
+            }
+            // 获取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绑定 重新绑定二维码`;
+                    }
+                    return '✅ 重新绑定成功！请重新执行 /mai发收藏品 操作。';
+                }
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 在调用API前加入队列
+            await waitForQueue(session);
+            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
+            // 使用新API获取收藏品（需要qr_text）
+            const machineInfo = config.machineInfo;
+            let result;
+            let usedCache = qrTextResult.fromCache === true;
+            try {
+                result = await api.getItem(machineInfo.regionId, machineInfo.regionName, machineInfo.clientId, machineInfo.placeId, machineInfo.placeName, parseInt(itemId, 10), itemKind, 1, // item_stock: 1
+                qrTextResult.qrText);
+            }
+            catch (error) {
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    }
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    result = await api.getItem(machineInfo.regionId, machineInfo.regionName, machineInfo.clientId, machineInfo.placeId, machineInfo.placeName, parseInt(itemId, 10), itemKind, 1, // item_stock: 1
+                    retryQrText.qrText);
+                }
+                else {
+                    // 如果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}`;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        result = await api.getItem(machineInfo.regionId, machineInfo.regionName, machineInfo.clientId, machineInfo.placeId, machineInfo.placeName, parseInt(itemId, 10), itemKind, 1, // item_stock: 1
+                        retryQrText.qrText);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+            }
+            if (!result.UserAllStatus || !result.LoginStatus || !result.LogoutStatus) {
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache && (!result.QrStatus || result.LoginStatus === false)) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    }
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    result = await api.getItem(machineInfo.regionId, machineInfo.regionName, machineInfo.clientId, machineInfo.placeId, machineInfo.placeName, parseInt(itemId, 10), itemKind, 1, // item_stock: 1
+                    retryQrText.qrText);
+                    if (!result.UserAllStatus || !result.LoginStatus || !result.LogoutStatus) {
+                        if (!result.QrStatus || result.LoginStatus === false) {
+                            const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                            if (rebindResult.success && rebindResult.newBinding) {
+                                return `✅ 重新绑定成功！请重新执行发收藏品操作。`;
+                            }
+                            return `❌ 发放收藏品失败：服务器返回未成功\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                        }
+                        return '❌ 发放收藏品失败：服务器返回未成功，请确认是否已在短时间内多次执行发收藏品指令或稍后再试或点击获取二维码刷新账号后再试。';
+                    }
+                }
+                else {
+                    // 如果返回失败，可能需要重新绑定
+                    if (!result.QrStatus || result.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)} 发放收藏品${proxyTip}\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}`;
+        }
+    });
     /**
      * 清收藏品
      * 用法: /mai清收藏品
@@ -3367,41 +3710,76 @@ function apply(ctx, config) {
             await waitForQueue(session);
             // 上传落雪B50（使用新API，需要qr_text）
             let result;
+            let usedCache = qrTextResult.fromCache === true;
             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);
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
                     if (retryQrText.error) {
-                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
                     }
                     // 在调用API前加入队列
                     await waitForQueue(session);
                     result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
                 }
                 else {
-                    throw 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}`;
+                        }
+                        // 在调用API前加入队列
+                        await waitForQueue(session);
+                        result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                    }
+                    else {
+                        throw error;
+                    }
                 }
             }
             if (!result.UploadStatus) {
-                if (result.msg === '该账号下存在未完成的任务') {
-                    return '⚠️ 当前账号已有未完成的落雪B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (usedCache && (result.msg?.includes('二维码') || result.msg?.includes('qr_text') || result.msg?.includes('无效'))) {
+                    logger.info('使用缓存的SGID失败，尝试重新获取SGID');
+                    const retryQrText = await getQrText(session, ctx, api, binding, config, rebindTimeout, undefined, false); // 禁用缓存，强制重新输入
+                    if (retryQrText.error) {
+                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                        return `❌ 上传失败：${result.msg || '未知错误'}\n获取新二维码失败：${retryQrText.error}${taskIdInfo}`;
+                    }
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                    if (!result.UploadStatus) {
+                        if (result.msg === '该账号下存在未完成的任务') {
+                            return '⚠️ 当前账号已有未完成的落雪B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                        }
+                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                        return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
+                    }
                 }
-                // 如果返回失败，可能需要重新绑定
-                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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                else {
+                    if (result.msg === '该账号下存在未完成的任务') {
+                        return '⚠️ 当前账号已有未完成的落雪B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                    }
+                    // 如果返回失败，可能需要重新绑定
+                    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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                        }
+                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                        return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
                     }
                     const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
-                    return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
+                    return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
                 }
-                const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
-                return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
             }
             scheduleLxB50Notification(session, result.task_id);
             return `✅ 落雪B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;