koishi-plugin-maibot 1.7.31 → 1.7.33

package/lib/index.js

@@ -67,6 +67,13 @@ exports.Config = koishi_1.Schema.object({
         interval: 10000,
         message: '你正在排队，前面还有 {queuePosition} 人。预计等待 {queueEST} 秒。',
     }),
+    operationLog: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().default(true).description('操作记录开关，开启后记录所有操作'),
+        refIdLabel: koishi_1.Schema.string().default('Ref_ID').description('Ref_ID 显示标签（可自定义），默认 "Ref_ID"'),
+    }).description('操作记录配置').default({
+        enabled: true,
+        refIdLabel: 'Ref_ID',
+    }),
 });
 // 我认识了很多朋友 以下是我认识的好朋友们！
 // Fracture_Hikaritsu
@@ -674,13 +681,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 +769,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 +929,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的消息`);
@@ -942,6 +966,54 @@ function apply(ctx, config) {
     // 初始化队列系统
     const queueConfig = config.queue || { enabled: false, interval: 10000, message: '你正在排队，前面还有 {queuePosition} 人。预计等待 {queueEST} 秒。' };
     const requestQueue = queueConfig.enabled ? new RequestQueue(queueConfig.interval) : null;
+    // 操作记录配置
+    const operationLogConfig = config.operationLog || { enabled: true, refIdLabel: 'Ref_ID' };
+    /**
+     * 生成唯一的 ref_id
+     */
+    function generateRefId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 9);
+        return `${timestamp}-${random}`.toUpperCase();
+    }
+    /**
+     * 记录操作日志
+     */
+    async function logOperation(params) {
+        if (!operationLogConfig.enabled) {
+            return '';
+        }
+        const refId = generateRefId();
+        try {
+            await ctx.database.create('maibot_operation_logs', {
+                refId,
+                command: params.command,
+                userId: params.session.userId || '',
+                targetUserId: params.targetUserId,
+                guildId: params.session.guildId || undefined,
+                channelId: params.session.channelId || undefined,
+                status: params.status,
+                result: params.result,
+                errorMessage: params.errorMessage,
+                apiResponse: params.apiResponse ? JSON.stringify(params.apiResponse) : undefined,
+                createdAt: new Date(),
+            });
+        }
+        catch (error) {
+            logger.warn(`记录操作日志失败: ${error?.message || '未知错误'}`);
+        }
+        return refId;
+    }
+    /**
+     * 在结果消息中添加 Ref_ID
+     */
+    function appendRefId(message, refId) {
+        if (!refId || !operationLogConfig.enabled) {
+            return message;
+        }
+        const label = operationLogConfig.refIdLabel || 'Ref_ID';
+        return `${message}\n${label}: ${refId}`;
+    }
     /**
      * 在API调用前加入队列并等待
      * 这个函数应该在获取到SGID后、调用API前使用
@@ -1652,11 +1724,27 @@ function apply(ctx, config) {
             }
             catch (error) {
                 ctx.logger('maibot').error('获取用户预览信息失败:', error);
-                return `❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`;
+                const errorMessage = `❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`;
+                const refId = await logOperation({
+                    command: 'mai绑定',
+                    session,
+                    status: 'error',
+                    errorMessage: error?.message || '未知错误',
+                    apiResponse: error?.response?.data,
+                });
+                return appendRefId(errorMessage, refId);
             }
             // 检查是否获取成功
             if (previewResult.UserID === -1 || (typeof previewResult.UserID === 'string' && previewResult.UserID === '-1')) {
-                return `❌ 绑定失败：无效或过期的二维码`;
+                const errorMessage = `❌ 绑定失败：无效或过期的二维码`;
+                const refId = await logOperation({
+                    command: 'mai绑定',
+                    session,
+                    status: 'failure',
+                    errorMessage: '无效或过期的二维码',
+                    apiResponse: previewResult,
+                });
+                return appendRefId(errorMessage, refId);
             }
             // UserID在新API中是加密的字符串
             const maiUid = String(previewResult.UserID);
@@ -1670,22 +1758,37 @@ function apply(ctx, config) {
                 bindTime: new Date(),
                 userName,
                 rating,
+                lastQrCode: qrCode, // 保存为缓存
+                lastQrCodeTime: new Date(), // 保存时间戳
             });
-            return `✅ 绑定成功！\n` +
+            const successMessage = `✅ 绑定成功！\n` +
                 (userName ? `用户名: ${userName}\n` : '') +
                 (rating ? `Rating: ${rating}\n` : '') +
                 `绑定时间: ${new Date().toLocaleString('zh-CN')}\n\n` +
                 `⚠️ 为了确保账户安全，请手动撤回群内包含SGID的消息`;
+            const refId = await logOperation({
+                command: 'mai绑定',
+                session,
+                status: 'success',
+                result: successMessage,
+            });
+            return appendRefId(successMessage, refId);
         }
         catch (error) {
             ctx.logger('maibot').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 errorMessage = maintenanceMode
+                ? maintenanceMessage
+                : (error?.response
+                    ? `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+                    : `❌ 绑定失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`);
+            const refId = await logOperation({
+                command: 'mai绑定',
+                session,
+                status: 'error',
+                errorMessage: error?.message || '未知错误',
+                apiResponse: error?.response?.data,
+            });
+            return appendRefId(errorMessage, refId);
         }
     });
     /**
@@ -1757,10 +1860,14 @@ function apply(ctx, config) {
                     statusInfo += `\n⚠️ 无法获取最新状态：${qrTextResult.error}`;
                 }
                 else {
-                    // 在调用API前加入队列
+                    // 在调用API前加入队列（只调用一次）
                     await waitForQueue(session);
                     try {
-                        const preview = await api.getPreview(machineInfo.clientId, qrTextResult.qrText);
+                        // 同时获取 preview 和 getCharge（并行执行，避免重复排队）
+                        const [preview, chargeResult] = await Promise.all([
+                            api.getPreview(machineInfo.clientId, qrTextResult.qrText),
+                            api.getCharge(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText)
+                        ]);
                         // 更新数据库中的用户名和Rating
                         await ctx.database.set('maibot_bindings', { userId }, {
                             userName: preview.UserName,
@@ -1803,6 +1910,9 @@ function apply(ctx, config) {
                             (versionInfo ? versionInfo : '') +
                             `登录状态: ${preview.IsLogin === true ? '已登录' : '未登录'}\n` +
                             `封禁状态: ${preview.BanState === 0 ? '正常' : '已封禁'}\n`;
+                        // 保存 chargeResult 供后续使用
+                        qrTextResultForCharge = { ...qrTextResult };
+                        qrTextResultForCharge.chargeResult = chargeResult;
                     }
                     catch (error) {
                         logger.warn('获取用户预览信息失败:', error);
@@ -1857,9 +1967,17 @@ function apply(ctx, config) {
             // 显示票券信息（使用新的getCharge API）
             try {
                 if (qrTextResultForCharge && !qrTextResultForCharge.error) {
-                    // 在调用API前加入队列
-                    await waitForQueue(session);
-                    const chargeResult = await api.getCharge(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResultForCharge.qrText);
+                    // 如果已经在上面获取了 chargeResult，直接使用；否则重新获取
+                    let chargeResult;
+                    if (qrTextResultForCharge.chargeResult) {
+                        // 已经在上面并行获取了，直接使用
+                        chargeResult = qrTextResultForCharge.chargeResult;
+                    }
+                    else {
+                        // 如果上面获取失败，这里重新获取（需要排队）
+                        await waitForQueue(session);
+                        chargeResult = await api.getCharge(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResultForCharge.qrText);
+                    }
                     if (chargeResult.ChargeStatus && chargeResult.userChargeList) {
                         const now = new Date();
                         const validTickets = [];
@@ -1918,10 +2036,26 @@ function apply(ctx, config) {
                 logger.warn('获取票券信息失败:', error);
                 statusInfo += `\n\n🎫 票券情况: 获取失败（${error?.message || '未知错误'}）`;
             }
-            return statusInfo;
+            const refId = await logOperation({
+                command: 'mai状态',
+                session,
+                targetUserId,
+                status: 'success',
+                result: statusInfo,
+            });
+            return appendRefId(statusInfo, refId);
         }
         catch (error) {
             ctx.logger('maibot').error('查询状态失败:', error);
+            const errorMessage = `❌ 查询状态失败: ${error?.message || '未知错误'}`;
+            const refId = await logOperation({
+                command: 'mai状态',
+                session,
+                targetUserId,
+                status: 'error',
+                errorMessage: error?.message || '未知错误',
+            });
+            return appendRefId(errorMessage, refId);
             if (maintenanceMode) {
                 return maintenanceMessage;
             }
@@ -2400,46 +2534,100 @@ 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}`;
+                    }
+                    // 在调用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 '❌ 发票失败：服务器返回未成功，请确认是否已在短时间内多次执行发票指令或稍后再试或点击获取二维码刷新账号后再试。';
                     }
-                    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 `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
+            const successMessage = `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
+            const refId = await logOperation({
+                command: 'mai发票',
+                session,
+                targetUserId,
+                status: 'success',
+                result: successMessage,
+            });
+            return appendRefId(successMessage, refId);
         }
         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 errorMessage = maintenanceMode
+                ? maintenanceMessage
+                : (error?.response
+                    ? `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`
+                    : `❌ 发票失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`);
+            const refId = await logOperation({
+                command: 'mai发票',
+                session,
+                targetUserId,
+                status: 'error',
+                errorMessage: error?.message || '未知错误',
+                apiResponse: error?.response?.data,
+            });
+            return appendRefId(errorMessage, refId);
         }
     });
     /**
@@ -2621,7 +2809,16 @@ function apply(ctx, config) {
                         return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
                     }
                     scheduleB50Notification(session, result.task_id);
-                    return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
+                    const successMessage = `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
+                    const refId = await logOperation({
+                        command: 'mai上传B50',
+                        session,
+                        targetUserId,
+                        status: 'success',
+                        result: successMessage,
+                        apiResponse: result,
+                    });
+                    return appendRefId(successMessage, refId);
                 }
                 return `❌ 获取二维码失败：${qrTextResult.error}`;
             }
@@ -2629,41 +2826,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分钟`;
@@ -2771,97 +3003,198 @@ function apply(ctx, config) {
                 return `❌ 获取二维码失败：${qrTextResult.error}`;
             }
             const results = [];
-            // 上传水鱼B50
-            const fishAbort = await (async () => {
-                try {
+            // 先上传水鱼B50，等待完成后再上传落雪（串行执行，避免同时登录）
+            try {
+                await waitForQueue(session);
+                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}` : '';
+                        return `🐟 水鱼: ❌ 上传失败：${fishResult.msg || '未知错误'}\n获取新二维码失败：${retryQrText.error}${taskIdInfo}`;
+                    }
+                    // 在调用API前加入队列
                     await waitForQueue(session);
-                    const fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, fishToken);
-                    if (!fishResult.UploadStatus) {
-                        if (fishResult.msg === '该账号下存在未完成的任务') {
-                            results.push('🐟 水鱼: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
-                            return null;
-                        }
-                        if (fishResult.msg?.includes('二维码') || fishResult.msg?.includes('qr_text') || fishResult.msg?.includes('无效')) {
-                            const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
-                            if (rebindResult.success && rebindResult.newBinding) {
-                                return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
-                            }
-                            const taskIdInfo = fishResult.task_id ? `\n任务ID: ${fishResult.task_id}` : '';
-                            return `❌ 水鱼上传失败：${fishResult.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
+                    fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, fishToken);
+                }
+                if (!fishResult.UploadStatus) {
+                    if (fishResult.msg === '该账号下存在未完成的任务') {
+                        results.push('🐟 水鱼: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
+                    }
+                    else if (fishResult.msg?.includes('二维码') || fishResult.msg?.includes('qr_text') || fishResult.msg?.includes('无效')) {
+                        const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                        if (rebindResult.success && rebindResult.newBinding) {
+                            return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
                         }
+                        const taskIdInfo = fishResult.task_id ? `\n任务ID: ${fishResult.task_id}` : '';
+                        return `❌ 水鱼上传失败：${fishResult.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
+                    }
+                    else {
                         const taskIdInfo = fishResult.task_id ? `\n任务ID: ${fishResult.task_id}` : '';
                         results.push(`🐟 水鱼: ❌ 上传失败：${fishResult.msg || '未知错误'}${taskIdInfo}`);
-                        return null;
                     }
+                }
+                else {
                     scheduleB50Notification(session, fishResult.task_id);
                     results.push(`🐟 水鱼: ✅ B50任务已提交！\n任务ID: ${fishResult.task_id}\n请耐心等待任务完成，预计1-10分钟`);
-                    return null;
                 }
-                catch (error) {
+            }
+            catch (error) {
+                // 如果使用了缓存且失败，尝试重新获取SGID
+                if (qrTextResult.fromCache) {
+                    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);
+                    try {
+                        const fishResult = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, fishToken);
+                        if (!fishResult.UploadStatus) {
+                            if (fishResult.msg === '该账号下存在未完成的任务') {
+                                results.push('🐟 水鱼: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
+                            }
+                            else {
+                                const taskIdInfo = fishResult.task_id ? `\n任务ID: ${fishResult.task_id}` : '';
+                                return `🐟 水鱼: ❌ 上传失败：${fishResult.msg || '未知错误'}${taskIdInfo}`;
+                            }
+                        }
+                        else {
+                            scheduleB50Notification(session, fishResult.task_id);
+                            results.push(`🐟 水鱼: ✅ B50任务已提交！\n任务ID: ${fishResult.task_id}\n请耐心等待任务完成，预计1-10分钟`);
+                        }
+                    }
+                    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')) {
+                            return '🐟 水鱼: ❌ 上传超时，请稍后再试一次。';
+                        }
+                        if (retryError?.response) {
+                            return `🐟 水鱼: ❌ API请求失败: ${retryError.response.status} ${retryError.response.statusText}`;
+                        }
+                        return `🐟 水鱼: ❌ 上传失败: ${retryError?.message || '未知错误'}`;
+                    }
+                }
+                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;
+                        return '🐟 水鱼: ❌ 上传超时，请稍后再试一次。';
                     }
                     if (error?.response) {
-                        results.push(`🐟 水鱼: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`);
-                        return null;
+                        return `🐟 水鱼: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`;
                     }
-                    results.push(`🐟 水鱼: ❌ 上传失败: ${error?.message || '未知错误'}`);
-                    return null;
+                    return `🐟 水鱼: ❌ 上传失败: ${error?.message || '未知错误'}`;
                 }
-            })();
-            if (fishAbort) {
-                return fishAbort;
             }
+            // 等待水鱼上传完成后再上传落雪（避免同时登录导致失败）
             // 上传落雪B50
-            const lxnsAbort = await (async () => {
-                try {
-                    await waitForQueue(session);
-                    const lxResult = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
-                    if (!lxResult.UploadStatus) {
-                        if (lxResult.msg === '该账号下存在未完成的任务') {
-                            results.push('❄️ 落雪: ⚠️ 当前账号已有未完成的B50任务，请稍后再试，无需重复上传。');
-                            return null;
-                        }
-                        if (lxResult.msg?.includes('二维码') || lxResult.msg?.includes('qr_text') || lxResult.msg?.includes('无效')) {
-                            const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
-                            if (rebindResult.success && rebindResult.newBinding) {
-                                return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
-                            }
-                            const taskIdInfo = lxResult.task_id ? `\n任务ID: ${lxResult.task_id}` : '';
-                            return `❌ 落雪上传失败：${lxResult.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
+            try {
+                await waitForQueue(session);
+                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}`);
+                    }
+                    else {
+                        // 在调用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任务，请稍后再试，无需重复上传。');
+                    }
+                    else if (lxResult.msg?.includes('二维码') || lxResult.msg?.includes('qr_text') || lxResult.msg?.includes('无效')) {
+                        const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                        if (rebindResult.success && rebindResult.newBinding) {
+                            return '✅ 重新绑定成功！请重新执行 /maiua 上传操作。';
                         }
+                        const taskIdInfo = lxResult.task_id ? `\n任务ID: ${lxResult.task_id}` : '';
+                        return `❌ 落雪上传失败：${lxResult.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
+                    }
+                    else {
                         const taskIdInfo = lxResult.task_id ? `\n任务ID: ${lxResult.task_id}` : '';
                         results.push(`❄️ 落雪: ❌ 上传失败：${lxResult.msg || '未知错误'}${taskIdInfo}`);
-                        return null;
                     }
+                }
+                else {
                     scheduleLxB50Notification(session, lxResult.task_id);
                     results.push(`❄️ 落雪: ✅ B50任务已提交！\n任务ID: ${lxResult.task_id}\n请耐心等待任务完成，预计1-10分钟`);
-                    return null;
                 }
-                catch (error) {
+            }
+            catch (error) {
+                // 如果使用了缓存且失败，尝试重新获取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}`);
+                    }
+                    else {
+                        // 在调用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任务，请稍后再试，无需重复上传。');
+                                }
+                                else {
+                                    const taskIdInfo = lxResult.task_id ? `\n任务ID: ${lxResult.task_id}` : '';
+                                    results.push(`❄️ 落雪: ❌ 上传失败：${lxResult.msg || '未知错误'}${taskIdInfo}`);
+                                }
+                            }
+                            else {
+                                scheduleLxB50Notification(session, lxResult.task_id);
+                                results.push(`❄️ 落雪: ✅ B50任务已提交！\n任务ID: ${lxResult.task_id}\n请耐心等待任务完成，预计1-10分钟`);
+                            }
+                        }
+                        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('❄️ 落雪: ❌ 上传超时，请稍后再试一次。');
+                            }
+                            else if (retryError?.response) {
+                                results.push(`❄️ 落雪: ❌ API请求失败: ${retryError.response.status} ${retryError.response.statusText}`);
+                            }
+                            else {
+                                results.push(`❄️ 落雪: ❌ 上传失败: ${retryError?.message || '未知错误'}`);
+                            }
+                        }
+                    }
+                }
+                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) {
+                    else if (error?.response) {
                         results.push(`❄️ 落雪: ❌ API请求失败: ${error.response.status} ${error.response.statusText}`);
-                        return null;
                     }
-                    results.push(`❄️ 落雪: ❌ 上传失败: ${error?.message || '未知错误'}`);
-                    return null;
+                    else {
+                        results.push(`❄️ 落雪: ❌ 上传失败: ${error?.message || '未知错误'}`);
+                    }
                 }
-            })();
-            if (lxnsAbort) {
-                return lxnsAbort;
             }
             if (results.length === 0) {
                 return `⚠️ 未能发起上传请求${proxyTip}`;
@@ -3060,18 +3393,18 @@ function apply(ctx, config) {
             // 使用新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) {
-                // 如果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);
@@ -3079,19 +3412,58 @@ function apply(ctx, config) {
                     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);
+                        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) {
-                // 如果返回失败，可能需要重新绑定
-                if (!result.QrStatus || result.LoginStatus === false) {
-                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
-                    if (rebindResult.success && rebindResult.newBinding) {
-                        return `✅ 重新绑定成功！请重新执行发收藏品操作。`;
+                // 如果使用了缓存且失败，尝试重新获取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 `❌ 发放收藏品失败：服务器返回未成功\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                    return '❌ 发放收藏品失败：服务器返回未成功，请确认是否已在短时间内多次执行发收藏品指令或稍后再试或点击获取二维码刷新账号后再试。';
                 }
-                return '❌ 发放收藏品失败：服务器返回未成功，请确认是否已在短时间内多次执行发收藏品指令或稍后再试或点击获取二维码刷新账号后再试。';
             }
             return `✅ 已为 ${maskUserId(binding.maiUid)} 发放收藏品${proxyTip}\n类型: ${selectedType?.label}\nID: ${itemId}`;
         }
@@ -3464,41 +3836,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分钟`;
@@ -4347,16 +4754,154 @@ function apply(ctx, config) {
             resultMessage = `ℹ️ 没有需要更新的用户\n所有用户都未开启锁定模式和保护模式`
           }
   
-          return resultMessage
-        } catch (error: any) {
-          logger.error('管理员一键关闭操作失败:', error)
-          if (maintenanceMode) {
-            return maintenanceMessage
-          }
-          return `❌ 操作失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
-        }
-      })
+        const refId = await logOperation({
+          command: 'mai管理员一键关闭',
+          session,
+          status: 'success',
+          result: resultMessage,
+        })
+        
+        return appendRefId(resultMessage, refId)
+      } catch (error: any) {
+        logger.error('管理员一键关闭操作失败:', error)
+        const errorMessage = maintenanceMode
+          ? maintenanceMessage
+          : `❌ 操作失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`
+        
+        const refId = await logOperation({
+          command: 'mai管理员一键关闭',
+          session,
+          status: 'error',
+          errorMessage: error?.message || '未知错误',
+        })
+        
+        return appendRefId(errorMessage, refId)
+      }
+    })
   
+    /**
+     * 管理员查询操作记录（通过 ref_id）
+     * 用法: /mai管理员查询操作 <ref_id>
+     */
+    ctx.command('mai管理员查询操作 <refId:text>', '通过 Ref_ID 查询操作详细信息（需要auth等级3以上）')
+        .userFields(['authority'])
+        .action(async ({ session }, refId) => {
+        if (!session) {
+            return '❌ 无法获取会话信息';
+        }
+        if ((session.user?.authority ?? 0) < 3) {
+            return '❌ 权限不足，需要auth等级3以上才能执行此操作';
+        }
+        try {
+            const logs = await ctx.database.get('maibot_operation_logs', { refId: refId.trim() });
+            if (logs.length === 0) {
+                return `❌ 未找到 Ref_ID 为 "${refId}" 的操作记录`;
+            }
+            const log = logs[0];
+            const statusText = {
+                success: '✅ 成功',
+                failure: '❌ 失败',
+                error: '⚠️ 错误',
+            }[log.status] || log.status;
+            let result = `📋 操作记录详情\n\n`;
+            result += `Ref_ID: ${log.refId}\n`;
+            result += `命令: ${log.command}\n`;
+            result += `操作人: ${log.userId}\n`;
+            if (log.targetUserId) {
+                result += `目标用户: ${log.targetUserId}\n`;
+            }
+            result += `状态: ${statusText}\n`;
+            result += `操作时间: ${new Date(log.createdAt).toLocaleString('zh-CN')}\n`;
+            if (log.guildId) {
+                result += `群组ID: ${log.guildId}\n`;
+            }
+            if (log.channelId) {
+                result += `频道ID: ${log.channelId}\n`;
+            }
+            if (log.result) {
+                result += `\n操作结果:\n${log.result}\n`;
+            }
+            if (log.errorMessage) {
+                result += `\n错误信息:\n${log.errorMessage}\n`;
+            }
+            if (log.apiResponse) {
+                try {
+                    const apiResp = JSON.parse(log.apiResponse);
+                    result += `\nAPI响应:\n${JSON.stringify(apiResp, null, 2)}\n`;
+                }
+                catch {
+                    result += `\nAPI响应:\n${log.apiResponse}\n`;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            logger.error('查询操作记录失败:', error);
+            return `❌ 查询失败: ${error?.message || '未知错误'}`;
+        }
+    });
+    /**
+     * 管理员查看今日命令统计
+     * 用法: /mai管理员统计
+     */
+    ctx.command('mai管理员统计', '查看今日各指令执行次数统计（需要auth等级3以上）')
+        .userFields(['authority'])
+        .action(async ({ session }) => {
+        if (!session) {
+            return '❌ 无法获取会话信息';
+        }
+        if ((session.user?.authority ?? 0) < 3) {
+            return '❌ 权限不足，需要auth等级3以上才能执行此操作';
+        }
+        try {
+            const today = new Date();
+            today.setHours(0, 0, 0, 0);
+            const todayStart = today.getTime();
+            // 获取今日所有操作记录
+            const allLogs = await ctx.database.get('maibot_operation_logs', {});
+            const todayLogs = allLogs.filter(log => new Date(log.createdAt).getTime() >= todayStart);
+            // 统计各命令执行次数
+            const commandStats = {};
+            for (const log of todayLogs) {
+                if (!commandStats[log.command]) {
+                    commandStats[log.command] = { total: 0, success: 0, failure: 0, error: 0 };
+                }
+                commandStats[log.command].total++;
+                if (log.status === 'success') {
+                    commandStats[log.command].success++;
+                }
+                else if (log.status === 'failure') {
+                    commandStats[log.command].failure++;
+                }
+                else if (log.status === 'error') {
+                    commandStats[log.command].error++;
+                }
+            }
+            // 按执行次数排序
+            const sortedCommands = Object.entries(commandStats).sort((a, b) => b[1].total - a[1].total);
+            let result = `📊 今日命令执行统计\n\n`;
+            result += `统计时间: ${new Date().toLocaleString('zh-CN')}\n`;
+            result += `总操作数: ${todayLogs.length}\n\n`;
+            if (sortedCommands.length === 0) {
+                result += `ℹ️ 今日暂无操作记录`;
+            }
+            else {
+                result += `各命令执行情况:\n`;
+                for (const [command, stats] of sortedCommands) {
+                    result += `\n${command}:\n`;
+                    result += `  总次数: ${stats.total}\n`;
+                    result += `  成功: ${stats.success}\n`;
+                    result += `  失败: ${stats.failure}\n`;
+                    result += `  错误: ${stats.error}\n`;
+                }
+            }
+            return result;
+        }
+        catch (error) {
+            logger.error('查询统计失败:', error);
+            return `❌ 查询失败: ${error?.message || '未知错误'}`;
+        }
+    });
     /**
      * 管理员关闭/开启登录播报功能（全局开关）
      * 用法: /mai管理员关闭登录播报 [on|off]