koishi-plugin-maibot 1.7.23 → 1.7.25

package/lib/index.js

@@ -367,9 +367,11 @@ class RequestQueue {
     }
     /**
      * 加入队列并等待处理
+     * @param userId 用户ID
+     * @param channelId 频道ID
      * @returns Promise<number>，当轮到处理时resolve，返回加入队列时的位置（0表示直接执行，没有排队）
      */
-    async enqueue() {
+    async enqueue(userId, channelId) {
         // 如果队列为空且距离上次处理已过间隔时间，直接执行
         if (this.queue.length === 0 && !this.processing) {
             const now = Date.now();
@@ -387,6 +389,8 @@ class RequestQueue {
                 resolve: () => resolve(queuePosition),
                 reject,
                 timestamp: Date.now(),
+                userId,
+                channelId,
             });
             // 启动处理循环（如果还没启动）
             if (!this.processing) {
@@ -424,6 +428,12 @@ class RequestQueue {
     getQueuePosition() {
         return this.queue.length;
     }
+    /**
+     * 检查是否正在处理
+     */
+    isProcessing() {
+        return this.processing;
+    }
     /**
      * 获取预计等待时间（秒）
      */
@@ -432,6 +442,88 @@ class RequestQueue {
         const waitTime = position * (this.interval / 1000);
         return Math.ceil(waitTime);
     }
+    /**
+     * 获取用户在队列中的位置
+     * @param userId 用户ID
+     * @param channelId 频道ID（可选，用于更精确的匹配）
+     * @returns 用户在队列中的位置（0表示正在处理或不在队列中，>0表示前面还有多少人）
+     */
+    getUserQueuePosition(userId, channelId) {
+        for (let i = 0; i < this.queue.length; i++) {
+            const task = this.queue[i];
+            if (task.userId === userId && (channelId === undefined || task.channelId === channelId)) {
+                // 返回位置（前面的人数），索引0表示第一个等待的人
+                return i + 1;
+            }
+        }
+        // 如果用户不在队列中，检查是否正在处理
+        if (this.processing && this.queue.length > 0) {
+            const firstTask = this.queue[0];
+            if (firstTask.userId === userId && (channelId === undefined || firstTask.channelId === channelId)) {
+                return 0; // 正在处理
+            }
+        }
+        return -1; // 不在队列中
+    }
+    /**
+     * 获取用户预计等待时间（秒）
+     * @param userId 用户ID
+     * @param channelId 频道ID（可选）
+     * @returns 预计等待时间（秒），-1表示不在队列中
+     */
+    getUserEstimatedWaitTime(userId, channelId) {
+        const position = this.getUserQueuePosition(userId, channelId);
+        if (position < 0) {
+            return -1;
+        }
+        if (position === 0) {
+            return 0; // 正在处理
+        }
+        const waitTime = position * (this.interval / 1000);
+        return Math.ceil(waitTime);
+    }
+}
+/**
+ * 处理并转换SGID（从URL或直接SGID）
+ * @param input 用户输入的SGID或URL
+ * @returns 转换后的SGID，如果格式错误返回null
+ */
+function processSGID(input) {
+    const trimmed = input.trim();
+    // 检查是否为公众号网页地址格式（https://wq.wahlap.net/qrcode/req/）
+    const isLink = trimmed.includes('https://wq.wahlap.net/qrcode/req/');
+    const isSGID = trimmed.startsWith('SGWCMAID');
+    let qrText = trimmed;
+    // 如果是网页地址，提取MAID并转换为SGWCMAID格式
+    if (isLink) {
+        try {
+            // 从URL中提取MAID部分：https://wq.wahlap.net/qrcode/req/MAID2601...55.html?...
+            // 匹配 /qrcode/req/ 后面的 MAID 开头的内容（到 .html 或 ? 之前）
+            const match = trimmed.match(/qrcode\/req\/(MAID[^?\.]+)/i);
+            if (match && match[1]) {
+                const maid = match[1];
+                // 在前面加上 SGWC 变成 SGWCMAID...
+                qrText = 'SGWC' + maid;
+            }
+            else {
+                return null;
+            }
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    else if (!isSGID) {
+        return null;
+    }
+    // 验证SGID格式和长度
+    if (!qrText.startsWith('SGWCMAID')) {
+        return null;
+    }
+    if (qrText.length < 48 || qrText.length > 128) {
+        return null;
+    }
+    return { qrText };
 }
 /**
  * 检查群是否在白名单中（如果白名单功能启用）
@@ -751,27 +843,43 @@ function apply(ctx, config) {
     const queueConfig = config.queue || { enabled: false, interval: 10000, message: '你正在排队，前面还有 {queuePosition} 人。预计等待 {queueEST} 秒。' };
     const requestQueue = queueConfig.enabled ? new RequestQueue(queueConfig.interval) : null;
     /**
-     * 队列包装函数：将命令action包装在队列中
+     * 在API调用前加入队列并等待
+     * 这个函数应该在获取到SGID后、调用API前使用
      */
-    async function withQueue(session, action) {
+    async function waitForQueue(session) {
         if (!requestQueue) {
-            // 队列未启用，直接执行
-            return action();
+            // 队列未启用，直接返回
+            return;
         }
-        // 加入队列并等待处理
-        const queuePosition = await requestQueue.enqueue();
-        // 如果前面有人（queuePosition > 0），说明用户排了队，发送队列提示
-        // 注意：这里queuePosition是加入队列时的位置，如果为0表示直接执行
-        if (queuePosition > 0) {
-            // 计算预计等待时间（基于加入时的位置）
+        // 检查必要的 session 属性
+        if (!session.userId || !session.channelId) {
+            logger.warn('无法加入队列：缺少 userId 或 channelId');
+            return;
+        }
+        // 先获取当前队列位置（不等待）
+        const currentQueueLength = requestQueue.getQueuePosition();
+        const isProcessing = requestQueue.isProcessing();
+        // 检查是否需要排队（如果队列不为空或正在处理，需要排队）
+        // 注意：即使队列为空，如果正在处理，也需要排队等待
+        const needsQueue = currentQueueLength > 0 || isProcessing;
+        // 如果需要排队，立即发送队列提示消息（在加入队列前发送，确保及时性）
+        if (needsQueue) {
+            // 计算队列位置（当前队列长度 + 1，因为用户即将加入）
+            const queuePosition = currentQueueLength + 1;
+            // 计算预计等待时间（基于队列位置）
             const estimatedWait = Math.ceil(queuePosition * (queueConfig.interval / 1000));
             const queueMessage = queueConfig.message
                 .replace(/{queuePosition}/g, String(queuePosition))
                 .replace(/{queueEST}/g, String(estimatedWait));
-            await session.send(queueMessage);
+            // 立即发送队列提示消息（不等待，使用 fire-and-forget 模式确保及时性）
+            // 使用 void 确保不等待 Promise 完成，同时捕获错误避免未处理的 Promise rejection
+            void session.send(queueMessage).catch(err => {
+                logger.warn('发送队列提示消息失败:', err);
+            });
         }
-        // 执行实际的操作
-        return action();
+        // 加入队列并等待处理
+        // 注意：即使发送了队列消息，这里仍然会等待队列处理完成
+        await requestQueue.enqueue(session.userId, session.channelId);
     }
     // 监听用户消息，尝试自动撤回包含SGID、水鱼token或落雪代码的消息
     if (config.autoRecall !== false) {
@@ -781,12 +889,19 @@ function apply(ctx, config) {
                 return;
             }
             const content = session.content?.trim() || '';
-            // 检查消息内容是否包含SGID或二维码链接
-            const isSGID = content.startsWith('SGWCMAID') || content.includes('https://wq.wahlap.net/qrcode/req/');
+            // 检查消息内容是否包含SGID或二维码链接（包括命令中的参数）
+            // 支持格式：/maiu SGWCMAID... 或 /maiu https://wq.wahlap.net/qrcode/req/...
+            // 支持格式：/maiul SGWCMAID... 或 /maiul https://wq.wahlap.net/qrcode/req/...
+            // 支持格式：/mai绑定 SGWCMAID... 或 /mai绑定 https://wq.wahlap.net/qrcode/req/...
+            const isSGID = content.includes('SGWCMAID') || content.includes('https://wq.wahlap.net/qrcode/req/');
             // 检查是否是水鱼token（长度127-132字符，且看起来像token）
-            const isFishToken = content.length >= 127 && content.length <= 132 && /^[a-zA-Z0-9+\/=_-]+$/.test(content);
+            // 注意：命令参数中的token也需要检测，所以不能只检查整条消息长度
+            const tokenMatch = content.match(/\b[a-zA-Z0-9+\/=_-]{127,132}\b/);
+            const isFishToken = tokenMatch !== null;
             // 检查是否是落雪代码（长度15字符，且看起来像代码）
-            const isLxnsCode = content.length === 15 && /^[a-zA-Z0-9]+$/.test(content);
+            // 注意：命令参数中的代码也需要检测
+            const codeMatch = content.match(/\b[a-zA-Z0-9]{15}\b/);
+            const isLxnsCode = codeMatch !== null && !isSGID; // 排除SGID的情况
             if ((isSGID || isFishToken || isLxnsCode) && session.messageId && session.channelId) {
                 // 延迟一小段时间后撤回（确保消息已被处理）
                 setTimeout(async () => {
@@ -1266,6 +1381,42 @@ function apply(ctx, config) {
         }
     });
     // 这个 Fracture_Hikaritsu 不给我吃KFC，故挂在此处。 我很生气。
+    /**
+     * 查询队列位置
+     * 用法: /maiqueue
+     */
+    ctx.command('maiqueue', '查询当前队列位置')
+        .action(async ({ session }) => {
+        if (!session) {
+            return '❌ 无法获取会话信息';
+        }
+        // 检查白名单
+        const whitelistCheck = checkWhitelist(session, config);
+        if (!whitelistCheck.allowed) {
+            return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
+        }
+        // 检查队列是否启用
+        if (!requestQueue) {
+            return 'ℹ️ 队列系统未启用';
+        }
+        // 检查必要的 session 属性
+        if (!session.userId || !session.channelId) {
+            return '❌ 无法查询队列：缺少用户信息';
+        }
+        // 查询用户在队列中的位置
+        const position = requestQueue.getUserQueuePosition(session.userId, session.channelId);
+        const estimatedWait = requestQueue.getUserEstimatedWaitTime(session.userId, session.channelId);
+        const totalQueue = requestQueue.getQueuePosition();
+        if (position < 0) {
+            return `ℹ️ 您当前不在队列中\n队列总长度: ${totalQueue}`;
+        }
+        else if (position === 0) {
+            return `✅ 您的请求正在处理中\n队列总长度: ${totalQueue}`;
+        }
+        else {
+            return `⏳ 您当前在队列中的位置: 第 ${position} 位\n预计等待时间: ${estimatedWait} 秒\n队列总长度: ${totalQueue}`;
+        }
+    });
     /**
      * 绑定用户
      * 用法: /mai绑定 [SGWCMAID...]
@@ -1281,174 +1432,158 @@ function apply(ctx, config) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
         // 使用队列系统
-        return withQueue(session, async () => {
-            const userId = session.userId;
-            try {
-                // 检查是否已绑定
-                const existing = await ctx.database.get('maibot_bindings', { userId });
-                if (existing.length > 0) {
-                    return `❌ 您已经绑定了账号\n绑定时间: ${new Date(existing[0].bindTime).toLocaleString('zh-CN')}\n\n如需重新绑定，请先使用 /mai解绑`;
-                }
-                // 如果没有提供SGID，提示用户输入
-                if (!qrCode) {
-                    const actualTimeout = rebindTimeout;
-                    let promptMessageId;
-                    try {
-                        const sentMessage = await session.send(`请在${actualTimeout / 1000}秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址`);
-                        if (typeof sentMessage === 'string') {
-                            promptMessageId = sentMessage;
-                        }
-                        else if (sentMessage && sentMessage.messageId) {
-                            promptMessageId = sentMessage.messageId;
-                        }
+        const userId = session.userId;
+        try {
+            // 检查是否已绑定
+            const existing = await ctx.database.get('maibot_bindings', { userId });
+            if (existing.length > 0) {
+                return `❌ 您已经绑定了账号\n绑定时间: ${new Date(existing[0].bindTime).toLocaleString('zh-CN')}\n\n如需重新绑定，请先使用 /mai解绑`;
+            }
+            // 如果没有提供SGID，提示用户输入
+            if (!qrCode) {
+                const actualTimeout = rebindTimeout;
+                let promptMessageId;
+                try {
+                    const sentMessage = await session.send(`请在${actualTimeout / 1000}秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址`);
+                    if (typeof sentMessage === 'string') {
+                        promptMessageId = sentMessage;
                     }
-                    catch (error) {
-                        ctx.logger('maibot').warn('发送提示消息失败:', error);
+                    else if (sentMessage && sentMessage.messageId) {
+                        promptMessageId = sentMessage.messageId;
                     }
-                    try {
-                        logger.info(`开始等待用户 ${session.userId} 输入SGID，超时时间: ${actualTimeout}ms`);
-                        // 使用session.prompt等待用户输入SGID文本
-                        const promptText = await session.prompt(actualTimeout);
-                        if (!promptText || !promptText.trim()) {
-                            throw new Error('超时未收到响应');
-                        }
-                        const trimmed = promptText.trim();
-                        logger.debug(`收到用户输入: ${trimmed.substring(0, 50)}`);
-                        qrCode = trimmed;
-                        // 检查是否为公众号网页地址格式（https://wq.wahlap.net/qrcode/req/）
-                        const isLink = trimmed.includes('https://wq.wahlap.net/qrcode/req/');
-                        const isSGID = trimmed.startsWith('SGWCMAID');
-                        // 如果是网页地址，提取MAID并转换为SGWCMAID格式
-                        if (isLink) {
-                            try {
-                                // 从URL中提取MAID部分：https://wq.wahlap.net/qrcode/req/MAID2601...55.html?...
-                                // 匹配 /qrcode/req/ 后面的 MAID 开头的内容（到 .html 或 ? 之前）
-                                const match = trimmed.match(/qrcode\/req\/(MAID[^?\.]+)/i);
-                                if (match && match[1]) {
-                                    const maid = match[1];
-                                    // 在前面加上 SGWC 变成 SGWCMAID...
-                                    qrCode = 'SGWC' + maid;
-                                    logger.info(`从网页地址提取MAID并转换: ${maid.substring(0, 20)}... -> ${qrCode.substring(0, 24)}...`);
-                                }
-                                else {
-                                    await session.send('⚠️ 无法从网页地址中提取MAID，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
-                                    throw new Error('无法从网页地址中提取MAID');
-                                }
+                }
+                catch (error) {
+                    ctx.logger('maibot').warn('发送提示消息失败:', error);
+                }
+                try {
+                    logger.info(`开始等待用户 ${session.userId} 输入SGID，超时时间: ${actualTimeout}ms`);
+                    // 使用session.prompt等待用户输入SGID文本
+                    const promptText = await session.prompt(actualTimeout);
+                    if (!promptText || !promptText.trim()) {
+                        throw new Error('超时未收到响应');
+                    }
+                    const trimmed = promptText.trim();
+                    logger.debug(`收到用户输入: ${trimmed.substring(0, 50)}`);
+                    qrCode = trimmed;
+                    // 检查是否为公众号网页地址格式（https://wq.wahlap.net/qrcode/req/）
+                    const isLink = trimmed.includes('https://wq.wahlap.net/qrcode/req/');
+                    const isSGID = trimmed.startsWith('SGWCMAID');
+                    // 如果是网页地址，提取MAID并转换为SGWCMAID格式
+                    if (isLink) {
+                        try {
+                            // 从URL中提取MAID部分：https://wq.wahlap.net/qrcode/req/MAID2601...55.html?...
+                            // 匹配 /qrcode/req/ 后面的 MAID 开头的内容（到 .html 或 ? 之前）
+                            const match = trimmed.match(/qrcode\/req\/(MAID[^?\.]+)/i);
+                            if (match && match[1]) {
+                                const maid = match[1];
+                                // 在前面加上 SGWC 变成 SGWCMAID...
+                                qrCode = 'SGWC' + maid;
+                                logger.info(`从网页地址提取MAID并转换: ${maid.substring(0, 20)}... -> ${qrCode.substring(0, 24)}...`);
                             }
-                            catch (error) {
-                                logger.warn('解析网页地址失败:', error);
-                                await session.send('⚠️ 网页地址格式错误，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
-                                throw new Error('网页地址格式错误');
+                            else {
+                                await session.send('⚠️ 无法从网页地址中提取MAID，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
+                                throw new Error('无法从网页地址中提取MAID');
                             }
                         }
-                        else if (!isSGID) {
-                            await session.send('⚠️ 未识别到有效的SGID格式或网页地址，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址（https://wq.wahlap.net/qrcode/req/...）');
-                            throw new Error('无效的二维码格式，必须是SGID文本或网页地址');
-                        }
-                        // 验证SGID格式和长度
-                        if (!qrCode.startsWith('SGWCMAID')) {
-                            await session.send('⚠️ 未识别到有效的SGID格式，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
-                            throw new Error('无效的二维码格式，必须以 SGWCMAID 开头');
-                        }
-                        if (qrCode.length < 48 || qrCode.length > 128) {
-                            await session.send('❌ SGID长度错误，应在48-128字符之间');
-                            throw new Error('二维码长度错误，应在48-128字符之间');
+                        catch (error) {
+                            logger.warn('解析网页地址失败:', error);
+                            await session.send('⚠️ 网页地址格式错误，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
+                            throw new Error('网页地址格式错误');
                         }
-                        logger.info(`✅ 接收到${isLink ? '网页地址（已转换）' : 'SGID'}: ${qrCode.substring(0, 50)}...`);
-                        // 发送识别中反馈
-                        await session.send('⏳ 正在处理，请稍候...');
                     }
-                    catch (error) {
-                        logger.error(`等待用户输入二维码失败: ${error?.message}`, error);
-                        if (error.message?.includes('超时') || error.message?.includes('timeout') || error.message?.includes('未收到响应')) {
-                            await session.send(`❌ 绑定超时（${actualTimeout / 1000}秒），请稍后使用 /mai绑定 重新绑定`);
-                            return '❌ 超时未收到响应，绑定已取消';
-                        }
-                        if (error.message?.includes('无效的二维码')) {
-                            return `❌ 绑定失败：${error.message}`;
-                        }
-                        await session.send(`❌ 绑定过程中发生错误：${error?.message || '未知错误'}`);
-                        return `❌ 绑定失败：${error?.message || '未知错误'}`;
+                    else if (!isSGID) {
+                        await session.send('⚠️ 未识别到有效的SGID格式或网页地址，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址（https://wq.wahlap.net/qrcode/req/...）');
+                        throw new Error('无效的二维码格式，必须是SGID文本或网页地址');
+                    }
+                    // 验证SGID格式和长度
+                    if (!qrCode.startsWith('SGWCMAID')) {
+                        await session.send('⚠️ 未识别到有效的SGID格式，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
+                        throw new Error('无效的二维码格式，必须以 SGWCMAID 开头');
+                    }
+                    if (qrCode.length < 48 || qrCode.length > 128) {
+                        await session.send('❌ SGID长度错误，应在48-128字符之间');
+                        throw new Error('二维码长度错误，应在48-128字符之间');
                     }
+                    logger.info(`✅ 接收到${isLink ? '网页地址（已转换）' : 'SGID'}: ${qrCode.substring(0, 50)}...`);
+                    // 发送识别中反馈
+                    await session.send('⏳ 正在处理，请稍候...');
                 }
-                // 检查是否为公众号网页地址格式（https://wq.wahlap.net/qrcode/req/）
-                const isLink = qrCode.includes('https://wq.wahlap.net/qrcode/req/');
-                const isSGID = qrCode.startsWith('SGWCMAID');
-                // 如果是网页地址，提取MAID并转换为SGWCMAID格式
-                if (isLink) {
-                    try {
-                        // 从URL中提取MAID部分：https://wq.wahlap.net/qrcode/req/MAID2601...55.html?...
-                        // 匹配 /qrcode/req/ 后面的 MAID 开头的内容（到 .html 或 ? 之前）
-                        const match = qrCode.match(/qrcode\/req\/(MAID[^?\.]+)/i);
-                        if (match && match[1]) {
-                            const maid = match[1];
-                            // 在前面加上 SGWC 变成 SGWCMAID...
-                            qrCode = 'SGWC' + maid;
-                            logger.info(`从网页地址提取MAID并转换: ${maid.substring(0, 20)}... -> ${qrCode.substring(0, 24)}...`);
-                        }
-                        else {
-                            return '❌ 无法从网页地址中提取MAID，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址';
-                        }
+                catch (error) {
+                    logger.error(`等待用户输入二维码失败: ${error?.message}`, error);
+                    if (error.message?.includes('超时') || error.message?.includes('timeout') || error.message?.includes('未收到响应')) {
+                        await session.send(`❌ 绑定超时（${actualTimeout / 1000}秒），请稍后使用 /mai绑定 重新绑定`);
+                        return '❌ 超时未收到响应，绑定已取消';
                     }
-                    catch (error) {
-                        logger.warn('解析网页地址失败:', error);
-                        return '❌ 网页地址格式错误，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址';
+                    if (error.message?.includes('无效的二维码')) {
+                        return `❌ 绑定失败：${error.message}`;
                     }
+                    await session.send(`❌ 绑定过程中发生错误：${error?.message || '未知错误'}`);
+                    return `❌ 绑定失败：${error?.message || '未知错误'}`;
                 }
-                else if (!isSGID) {
+            }
+            // 如果直接提供了qrCode参数，尝试撤回并处理
+            // 注意：如果qrCode是通过交互式输入获取的，已经在getQrText中处理过了
+            // 这里只处理直接通过参数提供的qrCode
+            if (qrCode && !qrCode.startsWith('SGWCMAID')) {
+                // 如果qrCode不是SGWCMAID格式，可能是原始输入，需要处理
+                await tryRecallMessage(session, ctx, config);
+                // 处理并转换SGID（从URL或直接SGID）
+                const processed = processSGID(qrCode);
+                if (!processed) {
                     return '❌ 二维码格式错误，必须是SGID文本（SGWCMAID开头）或公众号提供的网页地址（https://wq.wahlap.net/qrcode/req/...）';
                 }
-                // 验证SGID格式和长度
-                if (!qrCode.startsWith('SGWCMAID')) {
-                    return '❌ 二维码格式错误，必须以 SGWCMAID 开头';
-                }
-                if (qrCode.length < 48 || qrCode.length > 128) {
-                    return '❌ 二维码长度错误，应在48-128字符之间';
-                }
-                // 使用新API获取用户信息（需要client_id）
-                const machineInfo = config.machineInfo;
-                let previewResult;
-                try {
-                    previewResult = await api.getPreview(machineInfo.clientId, qrCode);
-                }
-                catch (error) {
-                    ctx.logger('maibot').error('获取用户预览信息失败:', error);
-                    return `❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`;
-                }
-                // 检查是否获取成功
-                if (previewResult.UserID === -1 || (typeof previewResult.UserID === 'string' && previewResult.UserID === '-1')) {
-                    return `❌ 绑定失败：无效或过期的二维码`;
-                }
-                // UserID在新API中是加密的字符串
-                const maiUid = String(previewResult.UserID);
-                const userName = previewResult.UserName;
-                const rating = previewResult.Rating ? String(previewResult.Rating) : undefined;
-                // 存储到数据库
-                await ctx.database.create('maibot_bindings', {
-                    userId,
-                    maiUid,
-                    qrCode,
-                    bindTime: new Date(),
-                    userName,
-                    rating,
-                });
-                return `✅ 绑定成功！\n` +
-                    (userName ? `用户名: ${userName}\n` : '') +
-                    (rating ? `Rating: ${rating}\n` : '') +
-                    `绑定时间: ${new Date().toLocaleString('zh-CN')}\n\n` +
-                    `⚠️ 为了确保账户安全，请手动撤回群内包含SGID的消息`;
+                qrCode = processed.qrText;
+                logger.info(`从参数中提取并转换SGID: ${qrCode.substring(0, 50)}...`);
+            }
+            else if (qrCode && qrCode.startsWith('SGWCMAID')) {
+                // 如果已经是SGWCMAID格式，说明可能是直接参数传入的，尝试撤回
+                await tryRecallMessage(session, ctx, config);
+            }
+            // 在调用API前加入队列
+            await waitForQueue(session);
+            // 使用新API获取用户信息（需要client_id）
+            const machineInfo = config.machineInfo;
+            let previewResult;
+            try {
+                previewResult = await api.getPreview(machineInfo.clientId, qrCode);
             }
             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}`;
+                ctx.logger('maibot').error('获取用户预览信息失败:', error);
+                return `❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`;
+            }
+            // 检查是否获取成功
+            if (previewResult.UserID === -1 || (typeof previewResult.UserID === 'string' && previewResult.UserID === '-1')) {
+                return `❌ 绑定失败：无效或过期的二维码`;
+            }
+            // UserID在新API中是加密的字符串
+            const maiUid = String(previewResult.UserID);
+            const userName = previewResult.UserName;
+            const rating = previewResult.Rating ? String(previewResult.Rating) : undefined;
+            // 存储到数据库
+            await ctx.database.create('maibot_bindings', {
+                userId,
+                maiUid,
+                qrCode,
+                bindTime: new Date(),
+                userName,
+                rating,
+            });
+            return `✅ 绑定成功！\n` +
+                (userName ? `用户名: ${userName}\n` : '') +
+                (rating ? `Rating: ${rating}\n` : '') +
+                `绑定时间: ${new Date().toLocaleString('zh-CN')}\n\n` +
+                `⚠️ 为了确保账户安全，请手动撤回群内包含SGID的消息`;
+        }
+        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}`;
+        }
     });
     /**
      * 解绑用户
@@ -1499,134 +1634,133 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        // 使用队列系统
-        return withQueue(session, async () => {
+        try {
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            let statusInfo = `✅ 已绑定账号\n\n` +
+                `绑定时间: ${new Date(binding.bindTime).toLocaleString('zh-CN')}\n` +
+                `🚨 /maialert查看账号提醒状态\n`;
+            // 尝试获取最新状态并更新数据库（需要新二维码）
             try {
-                // 获取目标用户绑定
-                const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-                if (error || !binding) {
-                    return error || '❌ 获取用户绑定失败';
-                }
-                const userId = binding.userId;
-                let statusInfo = `✅ 已绑定账号\n\n` +
-                    `绑定时间: ${new Date(binding.bindTime).toLocaleString('zh-CN')}\n` +
-                    `🚨 /maialert查看账号提醒状态\n`;
-                // 尝试获取最新状态并更新数据库（需要新二维码）
-                try {
-                    // 废弃旧的uid策略，每次都需要新的二维码
-                    const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout, '请在60秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址以查询账号状态');
-                    if (qrTextResult.error) {
-                        statusInfo += `\n⚠️ 无法获取最新状态：${qrTextResult.error}`;
-                    }
-                    else {
-                        try {
-                            const preview = await api.getPreview(machineInfo.clientId, qrTextResult.qrText);
-                            // 更新数据库中的用户名和Rating
-                            await ctx.database.set('maibot_bindings', { userId }, {
-                                userName: preview.UserName,
-                                rating: preview.Rating ? String(preview.Rating) : undefined,
-                            });
-                            // 格式化版本信息
-                            let versionInfo = '';
-                            if (preview.RomVersion && preview.DataVersion) {
-                                // 机台版本：取前两个数字，如 1.52.00 -> 1.52
-                                const romVersionMatch = preview.RomVersion.match(/^(\d+\.\d+)/);
-                                const romVersion = romVersionMatch ? romVersionMatch[1] : preview.RomVersion;
-                                // 数据版本：取前两个数字 + 最后两个数字转换为字母，如 1.50.09 -> 1.50 - I
-                                const dataVersionPrefixMatch = preview.DataVersion.match(/^(\d+\.\d+)/);
-                                const dataVersionPrefix = dataVersionPrefixMatch ? dataVersionPrefixMatch[1] : preview.DataVersion;
-                                // 从版本号末尾提取最后两位数字，如 "1.50.01" -> "01", "1.50.09" -> "09"
-                                // 匹配最后一个点后的数字（确保只匹配版本号末尾）
-                                let dataVersionLetter = '';
-                                // 匹配最后一个点后的1-2位数字
-                                const dataVersionMatch = preview.DataVersion.match(/\.(\d{1,2})$/);
-                                if (dataVersionMatch) {
-                                    // 提取数字字符串，如 "09" 或 "9"
-                                    const digitsStr = dataVersionMatch[1];
-                                    // 转换为数字，如 "09" -> 9, "9" -> 9
-                                    const versionNumber = parseInt(digitsStr, 10);
-                                    // 验证转换是否正确
-                                    if (!isNaN(versionNumber) && versionNumber >= 1) {
-                                        // 01 -> A, 02 -> B, ..., 09 -> I, 10 -> J, ..., 26 -> Z
-                                        // 使用模运算确保在 A-Z 范围内循环（27 -> A, 28 -> B, ...）
-                                        const letterIndex = ((versionNumber - 1) % 26) + 1;
-                                        // 转换为大写字母：A=65, B=66, ..., Z=90
-                                        dataVersionLetter = String.fromCharCode(64 + letterIndex).toUpperCase();
-                                    }
+                // 废弃旧的uid策略，每次都需要新的二维码
+                const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout, '请在60秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址以查询账号状态');
+                if (qrTextResult.error) {
+                    statusInfo += `\n⚠️ 无法获取最新状态：${qrTextResult.error}`;
+                }
+                else {
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    try {
+                        const preview = await api.getPreview(machineInfo.clientId, qrTextResult.qrText);
+                        // 更新数据库中的用户名和Rating
+                        await ctx.database.set('maibot_bindings', { userId }, {
+                            userName: preview.UserName,
+                            rating: preview.Rating ? String(preview.Rating) : undefined,
+                        });
+                        // 格式化版本信息
+                        let versionInfo = '';
+                        if (preview.RomVersion && preview.DataVersion) {
+                            // 机台版本：取前两个数字，如 1.52.00 -> 1.52
+                            const romVersionMatch = preview.RomVersion.match(/^(\d+\.\d+)/);
+                            const romVersion = romVersionMatch ? romVersionMatch[1] : preview.RomVersion;
+                            // 数据版本：取前两个数字 + 最后两个数字转换为字母，如 1.50.09 -> 1.50 - I
+                            const dataVersionPrefixMatch = preview.DataVersion.match(/^(\d+\.\d+)/);
+                            const dataVersionPrefix = dataVersionPrefixMatch ? dataVersionPrefixMatch[1] : preview.DataVersion;
+                            // 从版本号末尾提取最后两位数字，如 "1.50.01" -> "01", "1.50.09" -> "09"
+                            // 匹配最后一个点后的数字（确保只匹配版本号末尾）
+                            let dataVersionLetter = '';
+                            // 匹配最后一个点后的1-2位数字
+                            const dataVersionMatch = preview.DataVersion.match(/\.(\d{1,2})$/);
+                            if (dataVersionMatch) {
+                                // 提取数字字符串，如 "09" 或 "9"
+                                const digitsStr = dataVersionMatch[1];
+                                // 转换为数字，如 "09" -> 9, "9" -> 9
+                                const versionNumber = parseInt(digitsStr, 10);
+                                // 验证转换是否正确
+                                if (!isNaN(versionNumber) && versionNumber >= 1) {
+                                    // 01 -> A, 02 -> B, ..., 09 -> I, 10 -> J, ..., 26 -> Z
+                                    // 使用模运算确保在 A-Z 范围内循环（27 -> A, 28 -> B, ...）
+                                    const letterIndex = ((versionNumber - 1) % 26) + 1;
+                                    // 转换为大写字母：A=65, B=66, ..., Z=90
+                                    dataVersionLetter = String.fromCharCode(64 + letterIndex).toUpperCase();
                                 }
-                                versionInfo = `机台版本: ${romVersion}\n` +
-                                    `数据版本: ${dataVersionPrefix} - ${dataVersionLetter}\n`;
                             }
-                            statusInfo += `\n📊 账号信息：\n` +
-                                `用户名: ${preview.UserName || '未知'}\n` +
-                                `Rating: ${preview.Rating || '未知'}\n` +
-                                (versionInfo ? versionInfo : '') +
-                                `登录状态: ${preview.IsLogin === true ? '已登录' : '未登录'}\n` +
-                                `封禁状态: ${preview.BanState === 0 ? '正常' : '已封禁'}\n`;
-                        }
-                        catch (error) {
-                            logger.warn('获取用户预览信息失败:', error);
-                            statusInfo += `\n⚠️ 无法获取最新状态，请检查API服务`;
+                            versionInfo = `机台版本: ${romVersion}\n` +
+                                `数据版本: ${dataVersionPrefix} - ${dataVersionLetter}\n`;
                         }
+                        statusInfo += `\n📊 账号信息：\n` +
+                            `用户名: ${preview.UserName || '未知'}\n` +
+                            `Rating: ${preview.Rating || '未知'}\n` +
+                            (versionInfo ? versionInfo : '') +
+                            `登录状态: ${preview.IsLogin === true ? '已登录' : '未登录'}\n` +
+                            `封禁状态: ${preview.BanState === 0 ? '正常' : '已封禁'}\n`;
                     }
-                }
-                catch (error) {
-                    // 如果获取失败，使用缓存的信息
-                    if (binding.userName) {
-                        statusInfo += `\n📊 账号信息（缓存）：\n` +
-                            `用户名: ${binding.userName}\n` +
-                            (binding.rating ? `Rating: ${binding.rating}\n` : '');
+                    catch (error) {
+                        logger.warn('获取用户预览信息失败:', error);
+                        statusInfo += `\n⚠️ 无法获取最新状态，请检查API服务`;
                     }
-                    statusInfo += `\n⚠️ 无法获取最新状态，请检查API服务`;
                 }
-                // 显示水鱼Token绑定状态
-                if (binding.fishToken) {
-                    statusInfo += `\n\n🐟 水鱼Token: 已绑定`;
+            }
+            catch (error) {
+                // 如果获取失败，使用缓存的信息
+                if (binding.userName) {
+                    statusInfo += `\n📊 账号信息（缓存）：\n` +
+                        `用户名: ${binding.userName}\n` +
+                        (binding.rating ? `Rating: ${binding.rating}\n` : '');
+                }
+                statusInfo += `\n⚠️ 无法获取最新状态，请检查API服务`;
+            }
+            // 显示水鱼Token绑定状态
+            if (binding.fishToken) {
+                statusInfo += `\n\n🐟 水鱼Token: 已绑定`;
+            }
+            else {
+                statusInfo += `\n\n🐟 水鱼Token: 未绑定\n使用 /mai绑定水鱼 <token> 进行绑定`;
+            }
+            // 显示落雪代码绑定状态
+            if (binding.lxnsCode) {
+                statusInfo += `\n\n❄️ 落雪代码: 已绑定`;
+            }
+            else {
+                statusInfo += `\n\n❄️ 落雪代码: 未绑定\n使用 /mai绑定落雪 <lxns_code> 进行绑定`;
+            }
+            // 显示保护模式状态（如果未隐藏）
+            if (!hideLockAndProtection) {
+                if (binding.protectionMode) {
+                    statusInfo += `\n\n🛡️ 保护模式: 已开启\n使用 /mai保护模式 off 关闭`;
                 }
                 else {
-                    statusInfo += `\n\n🐟 水鱼Token: 未绑定\n使用 /mai绑定水鱼 <token> 进行绑定`;
+                    statusInfo += `\n\n🛡️ 保护模式: 未开启\n使用 /mai保护模式 on 开启（自动锁定已下线的账号）`;
                 }
-                // 显示落雪代码绑定状态
-                if (binding.lxnsCode) {
-                    statusInfo += `\n\n❄️ 落雪代码: 已绑定`;
+                // 显示锁定状态（不显示LoginId）
+                if (binding.isLocked) {
+                    const lockTime = binding.lockTime
+                        ? new Date(binding.lockTime).toLocaleString('zh-CN')
+                        : '未知';
+                    statusInfo += `\n\n🔒 锁定状态: 已锁定`;
+                    statusInfo += `\n锁定时间: ${lockTime}`;
+                    statusInfo += `\n使用 /mai解锁 可以解锁账号`;
                 }
                 else {
-                    statusInfo += `\n\n❄️ 落雪代码: 未绑定\n使用 /mai绑定落雪 <lxns_code> 进行绑定`;
+                    statusInfo += `\n\n🔒 锁定状态: 未锁定\n使用 /mai锁定 可以锁定账号（防止他人登录）`;
                 }
-                // 显示保护模式状态（如果未隐藏）
-                if (!hideLockAndProtection) {
-                    if (binding.protectionMode) {
-                        statusInfo += `\n\n🛡️ 保护模式: 已开启\n使用 /mai保护模式 off 关闭`;
-                    }
-                    else {
-                        statusInfo += `\n\n🛡️ 保护模式: 未开启\n使用 /mai保护模式 on 开启（自动锁定已下线的账号）`;
-                    }
-                    // 显示锁定状态（不显示LoginId）
-                    if (binding.isLocked) {
-                        const lockTime = binding.lockTime
-                            ? new Date(binding.lockTime).toLocaleString('zh-CN')
-                            : '未知';
-                        statusInfo += `\n\n🔒 锁定状态: 已锁定`;
-                        statusInfo += `\n锁定时间: ${lockTime}`;
-                        statusInfo += `\n使用 /mai解锁 可以解锁账号`;
-                    }
-                    else {
-                        statusInfo += `\n\n🔒 锁定状态: 未锁定\n使用 /mai锁定 可以锁定账号（防止他人登录）`;
-                    }
-                }
-                // 显示票券信息
-                // @deprecated getCharge功能已在新API中移除，已注释
-                statusInfo += `\n\n🎫 票券情况: 此功能已在新API中移除`;
-                return statusInfo;
             }
-            catch (error) {
-                ctx.logger('maibot').error('查询状态失败:', error);
-                if (maintenanceMode) {
-                    return maintenanceMessage;
-                }
-                return `❌ 查询失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
+            // 显示票券信息
+            // @deprecated getCharge功能已在新API中移除，已注释
+            statusInfo += `\n\n🎫 票券情况: 此功能已在新API中移除`;
+            return statusInfo;
+        }
+        catch (error) {
+            ctx.logger('maibot').error('查询状态失败:', error);
+            if (maintenanceMode) {
+                return maintenanceMessage;
             }
-        });
+            return `❌ 查询失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
+        }
     });
     /**
      * 锁定账号（登录保持）
@@ -2024,103 +2158,104 @@ function apply(ctx, config) {
         if (!Number.isInteger(multiple) || multiple < 2 || multiple > 6) {
             return '❌ 倍数必须是2-6之间的整数\n例如：/mai发票 3\n例如：/mai发票 6 @userid';
         }
-        // 使用队列系统
-        return withQueue(session, async () => {
-            try {
-                // 获取目标用户绑定
-                const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-                if (error || !binding) {
-                    return error || '❌ 获取用户绑定失败';
-                }
-                const userId = binding.userId;
-                const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
-                // 确认操作（如果未使用 -bypass）
-                if (!options?.bypass) {
-                    const baseTip = `⚠️ 即将发放 ${multiple} 倍票${proxyTip}`;
-                    const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
-                    if (!confirmFirst) {
-                        return '操作已取消（第一次确认未通过）';
-                    }
-                    const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
-                    if (!confirmSecond) {
-                        return '操作已取消（第二次确认未通过）';
-                    }
-                    if (multiple >= 3) {
-                        const confirmThird = await promptYesLocal(session, '第三次确认：3倍及以上票券风险更高，确定继续？');
-                        if (!confirmThird) {
-                            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绑定 重新绑定二维码`;
-                        }
-                        // 重新绑定成功后，使用新的binding
-                        const updatedBinding = rebindResult.newBinding || binding;
-                        const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
-                        if (retryQrText.error) {
-                            return `❌ 获取二维码失败：${retryQrText.error}`;
-                        }
-                        // 使用新的qrText继续
-                        await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-                        const ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
-                        if (!ticketResult.TicketStatus || !ticketResult.LoginStatus || !ticketResult.LogoutStatus) {
-                            return '❌ 发放功能票失败：服务器返回未成功，请稍后再试';
-                        }
-                        return `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
+        try {
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
+            // 确认操作（如果未使用 -bypass）
+            if (!options?.bypass) {
+                const baseTip = `⚠️ 即将发放 ${multiple} 倍票${proxyTip}`;
+                const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
+                if (!confirmFirst) {
+                    return '操作已取消（第一次确认未通过）';
+                }
+                const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
+                if (!confirmSecond) {
+                    return '操作已取消（第二次确认未通过）';
+                }
+                if (multiple >= 3) {
+                    const confirmThird = await promptYesLocal(session, '第三次确认：3倍及以上票券风险更高，确定继续？');
+                    if (!confirmThird) {
+                        return '操作已取消（第三次确认未通过）';
                     }
-                    return `❌ 获取二维码失败：${qrTextResult.error}`;
-                }
-                await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
-                // 使用新API获取功能票（需要qr_text）
-                let ticketResult;
-                try {
-                    ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, qrTextResult.qrText);
                 }
-                catch (error) {
-                    // 如果API返回失败，可能需要重新绑定
-                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                        // 重新绑定成功，重试获取功能票
-                        const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
-                        if (retryQrText.error) {
-                            return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
-                        }
-                        ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+            }
+            // 获取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绑定 重新绑定二维码`;
                     }
-                    else {
-                        throw error;
+                    // 重新绑定成功后，使用新的binding
+                    const updatedBinding = rebindResult.newBinding || binding;
+                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
                     }
-                }
-                if (!ticketResult.TicketStatus || !ticketResult.LoginStatus || !ticketResult.LogoutStatus) {
-                    // 如果返回失败，可能需要重新绑定
-                    if (!ticketResult.QrStatus || ticketResult.LoginStatus === false) {
-                        const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
-                        if (rebindResult.success && rebindResult.newBinding) {
-                            return `✅ 重新绑定成功！请重新执行发票操作。`;
-                        }
-                        return `❌ 发放功能票失败：服务器返回未成功\n重新绑定失败：${rebindResult.error || '未知错误'}`;
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    // 使用新的qrText继续
+                    await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
+                    const ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+                    if (!ticketResult.TicketStatus || !ticketResult.LoginStatus || !ticketResult.LogoutStatus) {
+                        return '❌ 发放功能票失败：服务器返回未成功，请稍后再试';
                     }
-                    return '❌ 发票失败：服务器返回未成功，请确认是否已在短时间内多次执行发票指令或稍后再试或点击获取二维码刷新账号后再试。';
+                    return `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
                 }
-                return `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 在调用API前加入队列
+            await waitForQueue(session);
+            await session.send('请求成功提交，请等待服务器响应。（通常需要2-3分钟）');
+            // 使用新API获取功能票（需要qr_text）
+            let ticketResult;
+            try {
+                ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, qrTextResult.qrText);
             }
             catch (error) {
-                logger.error('发票失败:', error);
-                if (maintenanceMode) {
-                    return maintenanceMessage;
+                // 如果API返回失败，可能需要重新绑定
+                const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                    // 重新绑定成功，重试获取功能票
+                    const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                    }
+                    ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
                 }
-                if (error?.response) {
-                    return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+                else {
+                    throw error;
                 }
-                return `❌ 发票失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
             }
-        });
+            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 `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
+        }
+        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}`;
+        }
     });
     /**
      * 舞里程发放 / 签到
@@ -2214,9 +2349,10 @@ function apply(ctx, config) {
      * 上传B50到水鱼
      * 用法: /mai上传B50 [@用户id]
      */
-    ctx.command('mai上传B50 [targetUserId:text]', '上传B50数据到水鱼')
+    ctx.command('mai上传B50 [qrCodeOrTarget:text]', '上传B50数据到水鱼')
+        .alias('maiu')
         .userFields(['authority'])
-        .action(async ({ session }, targetUserId) => {
+        .action(async ({ session }, qrCodeOrTarget) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -2225,112 +2361,148 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        // 使用队列系统
-        return withQueue(session, async () => {
-            try {
-                // 获取目标用户绑定
-                const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-                if (error || !binding) {
-                    return error || '❌ 获取用户绑定失败';
-                }
-                const userId = binding.userId;
-                // 检查是否已绑定水鱼Token
-                if (!binding.fishToken) {
-                    return '❌ 请先绑定水鱼Token\n使用 /mai绑定水鱼 <token> 进行绑定';
-                }
-                // 维护时间内直接提示，不发起上传请求
-                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
-                if (maintenanceMsg) {
-                    return maintenanceMsg;
+        try {
+            // 解析参数：可能是SGID或targetUserId
+            let qrCode;
+            let targetUserId;
+            // 检查第一个参数是否是SGID或URL
+            if (qrCodeOrTarget) {
+                const processed = processSGID(qrCodeOrTarget);
+                if (processed) {
+                    // 是SGID或URL，尝试撤回
+                    await tryRecallMessage(session, ctx, config);
+                    qrCode = processed.qrText;
                 }
-                // 获取qr_text（交互式或从绑定中获取）
-                const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
-                if (qrTextResult.error) {
-                    if (qrTextResult.needRebind) {
-                        const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
-                        if (!rebindResult.success) {
-                            return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
-                        }
-                        // 重新绑定成功后，使用新的binding
-                        const updatedBinding = rebindResult.newBinding || binding;
-                        const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
-                        if (retryQrText.error) {
-                            return `❌ 获取二维码失败：${retryQrText.error}`;
-                        }
-                        // 使用新的qrText继续
-                        const result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
-                        if (!result.UploadStatus) {
-                            if (result.msg === '该账号下存在未完成的任务') {
-                                return '⚠️ 当前账号已有未完成的水鱼B50任务，请稍后再试，无需重复上传。';
-                            }
-                            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分钟`;
-                    }
-                    return `❌ 获取二维码失败：${qrTextResult.error}`;
+                else {
+                    // 不是SGID，可能是targetUserId
+                    targetUserId = qrCodeOrTarget;
                 }
-                // 上传B50（使用新API，需要qr_text）
-                let result;
+            }
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            // 检查是否已绑定水鱼Token
+            if (!binding.fishToken) {
+                return '❌ 请先绑定水鱼Token\n使用 /mai绑定水鱼 <token> 进行绑定';
+            }
+            // 维护时间内直接提示，不发起上传请求
+            const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
+            if (maintenanceMsg) {
+                return maintenanceMsg;
+            }
+            // 获取qr_text（如果提供了SGID参数则直接使用，否则交互式获取）
+            let qrTextResult;
+            if (qrCode) {
+                // 验证qrCode是否有效
                 try {
-                    result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, binding.fishToken);
+                    const preview = await api.getPreview(config.machineInfo.clientId, qrCode);
+                    if (preview.UserID === -1 || (typeof preview.UserID === 'string' && preview.UserID === '-1')) {
+                        return '❌ 无效或过期的二维码，请重新发送';
+                    }
+                    qrTextResult = { qrText: qrCode };
                 }
                 catch (error) {
-                    // 如果API返回失败，可能需要重新绑定
-                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                        // 重新绑定成功，重试上传
-                        const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
-                        if (retryQrText.error) {
-                            return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
-                        }
-                        result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
-                    }
-                    else {
-                        throw error;
-                    }
+                    return `❌ 验证二维码失败：${error?.message || '未知错误'}`;
                 }
-                if (!result.UploadStatus) {
-                    if (result.msg === '该账号下存在未完成的任务') {
-                        return '⚠️ 当前账号已有未完成的水鱼B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+            }
+            else {
+                // 交互式获取
+                qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
+            }
+            if (qrTextResult.error) {
+                if (qrTextResult.needRebind) {
+                    const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
+                    if (!rebindResult.success) {
+                        return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
+                    }
+                    // 重新绑定成功后，使用新的binding
+                    const updatedBinding = rebindResult.newBinding || binding;
+                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
                     }
-                    // 如果返回失败，可能需要重新绑定
-                    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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    // 使用新的qrText继续
+                    const result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
+                    if (!result.UploadStatus) {
+                        if (result.msg === '该账号下存在未完成的任务') {
+                            return '⚠️ 当前账号已有未完成的水鱼B50任务，请稍后再试，无需重复上传。';
                         }
                         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分钟`;
                 }
-                scheduleB50Notification(session, result.task_id);
-                return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 在调用API前加入队列
+            await waitForQueue(session);
+            // 上传B50（使用新API，需要qr_text）
+            let result;
+            try {
+                result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, binding.fishToken);
             }
             catch (error) {
-                ctx.logger('maibot').error('上传B50失败:', error);
-                if (maintenanceMode) {
-                    return maintenanceMessage;
-                }
-                // 处理请求超时类错误，统一提示
-                if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
-                    let msg = '水鱼B50任务 上传失败，请稍后再试一次。';
-                    const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
-                    if (maintenanceMsg) {
-                        msg += `\n${maintenanceMsg}`;
+                // 如果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}`;
                     }
-                    msg += `\n\n${maintenanceMessage}`;
-                    return msg;
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
                 }
-                if (error?.response) {
-                    return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+                else {
+                    throw error;
                 }
-                return `❌ 上传失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
             }
-        });
+            if (!result.UploadStatus) {
+                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 || '未知错误'}${taskIdInfo}`;
+            }
+            scheduleB50Notification(session, result.task_id);
+            return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
+        }
+        catch (error) {
+            ctx.logger('maibot').error('上传B50失败:', error);
+            if (maintenanceMode) {
+                return maintenanceMessage;
+            }
+            // 处理请求超时类错误，统一提示
+            if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
+                let msg = '水鱼B50任务 上传失败，请稍后再试一次。';
+                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
+                if (maintenanceMsg) {
+                    msg += `\n${maintenanceMsg}`;
+                }
+                msg += `\n\n${maintenanceMessage}`;
+                return msg;
+            }
+            if (error?.response) {
+                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+            }
+            return `❌ 上传失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
+        }
     });
     /**
      * 清空功能票
@@ -2779,9 +2951,10 @@ function apply(ctx, config) {
      * 上传落雪B50
      * 用法: /mai上传落雪b50 [lxns_code] [@用户id]
      */
-    ctx.command('mai上传落雪b50 [lxnsCode:text] [targetUserId:text]', '上传B50数据到落雪')
+    ctx.command('mai上传落雪b50 [qrCodeOrLxnsCode:text] [targetUserId:text]', '上传B50数据到落雪')
+        .alias('maiul')
         .userFields(['authority'])
-        .action(async ({ session }, lxnsCode, targetUserId) => {
+        .action(async ({ session }, qrCodeOrLxnsCode, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -2790,125 +2963,162 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        // 使用队列系统
-        return withQueue(session, async () => {
-            try {
-                // 获取目标用户绑定
-                const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-                if (error || !binding) {
-                    return error || '❌ 获取用户绑定失败';
-                }
-                const userId = binding.userId;
-                // 确定使用的落雪代码
-                let finalLxnsCode;
-                if (lxnsCode) {
-                    // 如果提供了参数，使用参数
-                    // 验证落雪代码长度
-                    if (lxnsCode.length !== 15) {
-                        return '❌ 落雪代码长度错误，必须为15个字符';
-                    }
-                    finalLxnsCode = lxnsCode;
+        try {
+            // 解析参数：第一个参数可能是SGID/URL或落雪代码
+            let qrCode;
+            let lxnsCode;
+            let actualTargetUserId = targetUserId;
+            // 检查第一个参数是否是SGID或URL
+            if (qrCodeOrLxnsCode) {
+                const processed = processSGID(qrCodeOrLxnsCode);
+                if (processed) {
+                    // 是SGID或URL，尝试撤回
+                    await tryRecallMessage(session, ctx, config);
+                    qrCode = processed.qrText;
+                }
+                else if (qrCodeOrLxnsCode.length === 15) {
+                    // 可能是落雪代码（15个字符）
+                    lxnsCode = qrCodeOrLxnsCode;
                 }
                 else {
-                    // 如果没有提供参数，使用绑定的代码
-                    if (!binding.lxnsCode) {
-                        return '❌ 请先绑定落雪代码或提供落雪代码参数\n使用 /mai绑定落雪 <lxns_code> 进行绑定\n或使用 /mai上传落雪b50 <lxns_code> 直接提供代码';
-                    }
-                    finalLxnsCode = binding.lxnsCode;
+                    // 可能是targetUserId
+                    actualTargetUserId = qrCodeOrLxnsCode;
                 }
-                // 维护时间内直接提示，不发起上传请求
-                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
-                if (maintenanceMsg) {
-                    return maintenanceMsg;
-                }
-                // 获取qr_text（交互式或从绑定中获取）
-                const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
-                if (qrTextResult.error) {
-                    if (qrTextResult.needRebind) {
-                        const rebindResult = await promptForRebind(session, ctx, api, binding, config, rebindTimeout);
-                        if (!rebindResult.success) {
-                            return `❌ 重新绑定失败：${rebindResult.error || '未知错误'}\n请使用 /mai绑定 重新绑定二维码`;
-                        }
-                        // 重新绑定成功后，使用新的binding
-                        const updatedBinding = rebindResult.newBinding || binding;
-                        const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
-                        if (retryQrText.error) {
-                            return `❌ 获取二维码失败：${retryQrText.error}`;
-                        }
-                        // 使用新的qrText继续
-                        const result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
-                        if (!result.UploadStatus) {
-                            if (result.msg === '该账号下存在未完成的任务') {
-                                return '⚠️ 当前账号已有未完成的落雪B50任务，请稍后再试，无需重复上传。';
-                            }
-                            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分钟`;
-                    }
-                    return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, actualTargetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            // 确定使用的落雪代码
+            let finalLxnsCode;
+            if (lxnsCode) {
+                // 如果提供了参数，使用参数
+                finalLxnsCode = lxnsCode;
+            }
+            else {
+                // 如果没有提供参数，使用绑定的代码
+                if (!binding.lxnsCode) {
+                    return '❌ 请先绑定落雪代码或提供落雪代码参数\n使用 /mai绑定落雪 <lxns_code> 进行绑定\n或使用 /mai上传落雪b50 <lxns_code> 直接提供代码';
                 }
-                // 上传落雪B50（使用新API，需要qr_text）
-                let result;
+                finalLxnsCode = binding.lxnsCode;
+            }
+            // 维护时间内直接提示，不发起上传请求
+            const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
+            if (maintenanceMsg) {
+                return maintenanceMsg;
+            }
+            // 获取qr_text（如果提供了SGID参数则直接使用，否则交互式获取）
+            let qrTextResult;
+            if (qrCode) {
+                // 验证qrCode是否有效
                 try {
-                    result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
+                    const preview = await api.getPreview(config.machineInfo.clientId, qrCode);
+                    if (preview.UserID === -1 || (typeof preview.UserID === 'string' && preview.UserID === '-1')) {
+                        return '❌ 无效或过期的二维码，请重新发送';
+                    }
+                    qrTextResult = { qrText: qrCode };
                 }
                 catch (error) {
-                    // 如果API返回失败，可能需要重新绑定
-                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                        // 重新绑定成功，重试上传
-                        const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
-                        if (retryQrText.error) {
-                            return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
-                        }
-                        result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
-                    }
-                    else {
-                        throw error;
-                    }
+                    return `❌ 验证二维码失败：${error?.message || '未知错误'}`;
                 }
-                if (!result.UploadStatus) {
-                    if (result.msg === '该账号下存在未完成的任务') {
-                        return '⚠️ 当前账号已有未完成的落雪B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+            }
+            else {
+                // 交互式获取
+                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绑定 重新绑定二维码`;
                     }
-                    // 如果返回失败，可能需要重新绑定
-                    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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                    // 重新绑定成功后，使用新的binding
+                    const updatedBinding = rebindResult.newBinding || binding;
+                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
+                    if (retryQrText.error) {
+                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    }
+                    // 在调用API前加入队列
+                    await waitForQueue(session);
+                    // 使用新的qrText继续
+                    const result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                    if (!result.UploadStatus) {
+                        if (result.msg === '该账号下存在未完成的任务') {
+                            return '⚠️ 当前账号已有未完成的落雪B50任务，请稍后再试，无需重复上传。';
                         }
                         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分钟`;
                 }
-                scheduleLxB50Notification(session, result.task_id);
-                return `✅ 落雪B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
+                return `❌ 获取二维码失败：${qrTextResult.error}`;
+            }
+            // 在调用API前加入队列
+            await waitForQueue(session);
+            // 上传落雪B50（使用新API，需要qr_text）
+            let result;
+            try {
+                result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
             }
             catch (error) {
-                ctx.logger('maibot').error('上传落雪B50失败:', error);
-                if (maintenanceMode) {
-                    return maintenanceMessage;
-                }
-                // 处理请求超时类错误，统一提示
-                if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
-                    let msg = '落雪B50任务 上传失败，请稍后再试一次。';
-                    const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
-                    if (maintenanceMsg) {
-                        msg += `\n${maintenanceMsg}`;
+                // 如果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分钟，无需重复上传。';
+                }
+                // 如果返回失败，可能需要重新绑定
+                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 `✅ 重新绑定成功！请重新执行上传操作。`;
                     }
-                    msg += `\n\n${maintenanceMessage}`;
-                    return msg;
+                    const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
+                    return `❌ 上传失败：${result.msg || '未知错误'}\n重新绑定失败：${rebindResult.error || '未知错误'}${taskIdInfo}`;
                 }
-                if (error?.response) {
-                    return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+                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分钟`;
+        }
+        catch (error) {
+            ctx.logger('maibot').error('上传落雪B50失败:', error);
+            if (maintenanceMode) {
+                return maintenanceMessage;
+            }
+            // 处理请求超时类错误，统一提示
+            if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
+                let msg = '落雪B50任务 上传失败，请稍后再试一次。';
+                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
+                if (maintenanceMsg) {
+                    msg += `\n${maintenanceMsg}`;
                 }
-                return `❌ 上传失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
+                msg += `\n\n${maintenanceMessage}`;
+                return msg;
             }
-        });
+            if (error?.response) {
+                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+            }
+            return `❌ 上传失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
+        }
     });
     // 查询落雪B50任务状态功能已暂时取消
     /**