koishi-plugin-maibot 1.7.22 → 1.7.24

package/lib/index.js

@@ -58,6 +58,15 @@ exports.Config = koishi_1.Schema.object({
         message: '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。',
     }),
     autoRecall: koishi_1.Schema.boolean().default(true).description('自动撤回用户发送的SGID消息（尝试撤回，如不支持则忽略）'),
+    queue: koishi_1.Schema.object({
+        enabled: koishi_1.Schema.boolean().default(false).description('队列系统开关，开启后限制并发请求'),
+        interval: koishi_1.Schema.number().default(10000).description('处理间隔（毫秒），默认10秒（10000毫秒），每间隔时间只处理一个请求'),
+        message: koishi_1.Schema.string().default('你正在排队，前面还有 {queuePosition} 人。预计等待 {queueEST} 秒。').description('队列提示消息模板（支持占位符：{queuePosition} 队列位置，{queueEST} 预计等待秒数）'),
+    }).description('请求队列配置').default({
+        enabled: false,
+        interval: 10000,
+        message: '你正在排队，前面还有 {queuePosition} 人。预计等待 {queueEST} 秒。',
+    }),
 });
 // 我认识了很多朋友 以下是我认识的好朋友们！
 // Fracture_Hikaritsu
@@ -346,6 +355,126 @@ async function extractQRCodeFromSession(session, ctx) {
     }
     return null;
 }
+/**
+ * 队列管理器
+ */
+class RequestQueue {
+    constructor(interval) {
+        this.queue = [];
+        this.processing = false;
+        this.lastProcessTime = 0;
+        this.interval = interval;
+    }
+    /**
+     * 加入队列并等待处理
+     * @returns Promise<number>，当轮到处理时resolve，返回加入队列时的位置（0表示直接执行，没有排队）
+     */
+    async enqueue() {
+        // 如果队列为空且距离上次处理已过间隔时间，直接执行
+        if (this.queue.length === 0 && !this.processing) {
+            const now = Date.now();
+            const timeSinceLastProcess = now - this.lastProcessTime;
+            if (timeSinceLastProcess >= this.interval) {
+                this.lastProcessTime = now;
+                return Promise.resolve(0); // 0表示直接执行，没有排队
+            }
+        }
+        // 需要加入队列
+        return new Promise((resolve, reject) => {
+            // 记录加入队列时的位置（这是用户前面的人数）
+            const queuePosition = this.queue.length;
+            this.queue.push({
+                resolve: () => resolve(queuePosition),
+                reject,
+                timestamp: Date.now(),
+            });
+            // 启动处理循环（如果还没启动）
+            if (!this.processing) {
+                // 使用setTimeout避免阻塞
+                setTimeout(() => {
+                    this.processQueue();
+                }, 0);
+            }
+        });
+    }
+    /**
+     * 处理队列
+     */
+    async processQueue() {
+        while (this.queue.length > 0) {
+            this.processing = true;
+            // 等待间隔时间
+            const now = Date.now();
+            const timeSinceLastProcess = now - this.lastProcessTime;
+            if (timeSinceLastProcess < this.interval) {
+                await new Promise(resolve => setTimeout(resolve, this.interval - timeSinceLastProcess));
+            }
+            // 处理队列中的第一个任务
+            if (this.queue.length > 0) {
+                const task = this.queue.shift();
+                this.lastProcessTime = Date.now();
+                task.resolve();
+            }
+        }
+        this.processing = false;
+    }
+    /**
+     * 获取队列位置
+     */
+    getQueuePosition() {
+        return this.queue.length;
+    }
+    /**
+     * 获取预计等待时间（秒）
+     */
+    getEstimatedWaitTime() {
+        const position = this.getQueuePosition();
+        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 };
+}
 /**
  * 检查群是否在白名单中（如果白名单功能启用）
  */
@@ -660,6 +789,32 @@ function apply(ctx, config) {
         timeout: config.apiTimeout,
     });
     const logger = ctx.logger('maibot');
+    // 初始化队列系统
+    const queueConfig = config.queue || { enabled: false, interval: 10000, message: '你正在排队，前面还有 {queuePosition} 人。预计等待 {queueEST} 秒。' };
+    const requestQueue = queueConfig.enabled ? new RequestQueue(queueConfig.interval) : null;
+    /**
+     * 队列包装函数：将命令action包装在队列中
+     */
+    async function withQueue(session, action) {
+        if (!requestQueue) {
+            // 队列未启用，直接执行
+            return action();
+        }
+        // 加入队列并等待处理
+        const queuePosition = await requestQueue.enqueue();
+        // 如果前面有人（queuePosition > 0），说明用户排了队，发送队列提示
+        // 注意：这里queuePosition是加入队列时的位置，如果为0表示直接执行
+        if (queuePosition > 0) {
+            // 计算预计等待时间（基于加入时的位置）
+            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);
+        }
+        // 执行实际的操作
+        return action();
+    }
     // 监听用户消息，尝试自动撤回包含SGID、水鱼token或落雪代码的消息
     if (config.autoRecall !== false) {
         ctx.on('message', async (session) => {
@@ -668,12 +823,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 () => {
@@ -1167,172 +1329,159 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        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;
-                    }
-                }
-                catch (error) {
-                    ctx.logger('maibot').warn('发送提示消息失败:', error);
+        // 使用队列系统
+        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解绑`;
                 }
-                try {
-                    logger.info(`开始等待用户 ${session.userId} 输入SGID，超时时间: ${actualTimeout}ms`);
-                    // 使用session.prompt等待用户输入SGID文本
-                    const promptText = await session.prompt(actualTimeout);
-                    if (!promptText || !promptText.trim()) {
-                        throw new Error('超时未收到响应');
+                // 如果没有提供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 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) {
+                        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)}...`);
+                                }
+                                else {
+                                    await session.send('⚠️ 无法从网页地址中提取MAID，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
+                                    throw new Error('无法从网页地址中提取MAID');
+                                }
                             }
-                            else {
-                                await session.send('⚠️ 无法从网页地址中提取MAID，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
-                                throw new Error('无法从网页地址中提取MAID');
+                            catch (error) {
+                                logger.warn('解析网页地址失败:', error);
+                                await session.send('⚠️ 网页地址格式错误，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
+                                throw new Error('网页地址格式错误');
                             }
                         }
-                        catch (error) {
-                            logger.warn('解析网页地址失败:', error);
-                            await session.send('⚠️ 网页地址格式错误，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址');
-                            throw new Error('网页地址格式错误');
+                        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('⏳ 正在处理，请稍候...');
                     }
-                    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.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 || '未知错误'}`;
                     }
-                    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}`;
+                // 如果直接提供了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/...）';
                     }
-                    await session.send(`❌ 绑定过程中发生错误：${error?.message || '未知错误'}`);
-                    return `❌ 绑定失败：${error?.message || '未知错误'}`;
+                    qrCode = processed.qrText;
+                    logger.info(`从参数中提取并转换SGID: ${qrCode.substring(0, 50)}...`);
                 }
-            }
-            // 检查是否为公众号网页地址格式（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) {
+                else if (qrCode && qrCode.startsWith('SGWCMAID')) {
+                    // 如果已经是SGWCMAID格式，说明可能是直接参数传入的，尝试撤回
+                    await tryRecallMessage(session, ctx, config);
+                }
+                // 使用新API获取用户信息（需要client_id）
+                const machineInfo = config.machineInfo;
+                let previewResult;
                 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开头）或公众号提供的网页地址';
-                    }
+                    previewResult = await api.getPreview(machineInfo.clientId, qrCode);
                 }
                 catch (error) {
-                    logger.warn('解析网页地址失败:', error);
-                    return '❌ 网页地址格式错误，请发送SGID文本（SGWCMAID开头）或公众号提供的网页地址';
+                    ctx.logger('maibot').error('获取用户预览信息失败:', error);
+                    return `❌ 绑定失败：无法从二维码获取用户信息\n错误信息: ${error?.message || '未知错误'}`;
                 }
-            }
-            else if (!isSGID) {
-                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);
+                // 检查是否获取成功
+                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);
-                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}`;
+                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}`;
             }
-            return `❌ 绑定失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
+        });
     });
     /**
      * 解绑用户
@@ -1383,131 +1532,134 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            let statusInfo = `✅ 已绑定账号\n\n` +
-                `绑定时间: ${new Date(binding.bindTime).toLocaleString('zh-CN')}\n` +
-                `🚨 /maialert查看账号提醒状态\n`;
-            // 尝试获取最新状态并更新数据库（需要新二维码）
+        // 使用队列系统
+        return withQueue(session, async () => {
             try {
-                // 废弃旧的uid策略，每次都需要新的二维码
-                const qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout, '请在60秒内发送SGID（长按玩家二维码识别后发送）或公众号提供的网页地址以查询账号状态');
-                if (qrTextResult.error) {
-                    statusInfo += `\n⚠️ 无法获取最新状态：${qrTextResult.error}`;
+                // 获取目标用户绑定
+                const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+                if (error || !binding) {
+                    return 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();
+                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();
+                                    }
                                 }
+                                versionInfo = `机台版本: ${romVersion}\n` +
+                                    `数据版本: ${dataVersionPrefix} - ${dataVersionLetter}\n`;
                             }
-                            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服务`;
                         }
-                        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服务`;
                     }
                 }
-            }
-            catch (error) {
-                // 如果获取失败，使用缓存的信息
-                if (binding.userName) {
-                    statusInfo += `\n📊 账号信息（缓存）：\n` +
-                        `用户名: ${binding.userName}\n` +
-                        (binding.rating ? `Rating: ${binding.rating}\n` : '');
+                catch (error) {
+                    // 如果获取失败，使用缓存的信息
+                    if (binding.userName) {
+                        statusInfo += `\n📊 账号信息（缓存）：\n` +
+                            `用户名: ${binding.userName}\n` +
+                            (binding.rating ? `Rating: ${binding.rating}\n` : '');
+                    }
+                    statusInfo += `\n⚠️ 无法获取最新状态，请检查API服务`;
                 }
-                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 关闭`;
+                // 显示水鱼Token绑定状态
+                if (binding.fishToken) {
+                    statusInfo += `\n\n🐟 水鱼Token: 已绑定`;
                 }
                 else {
-                    statusInfo += `\n\n🛡️ 保护模式: 未开启\n使用 /mai保护模式 on 开启（自动锁定已下线的账号）`;
+                    statusInfo += `\n\n🐟 水鱼Token: 未绑定\n使用 /mai绑定水鱼 <token> 进行绑定`;
                 }
-                // 显示锁定状态（不显示LoginId）
-                if (binding.isLocked) {
-                    const lockTime = binding.lockTime
-                        ? new Date(binding.lockTime).toLocaleString('zh-CN')
-                        : '未知';
-                    statusInfo += `\n\n🔒 锁定状态: 已锁定`;
-                    statusInfo += `\n锁定时间: ${lockTime}`;
-                    statusInfo += `\n使用 /mai解锁 可以解锁账号`;
+                // 显示落雪代码绑定状态
+                if (binding.lxnsCode) {
+                    statusInfo += `\n\n❄️ 落雪代码: 已绑定`;
                 }
                 else {
-                    statusInfo += `\n\n🔒 锁定状态: 未锁定\n使用 /mai锁定 可以锁定账号（防止他人登录）`;
+                    statusInfo += `\n\n❄️ 落雪代码: 未绑定\n使用 /mai绑定落雪 <lxns_code> 进行绑定`;
+                }
+                // 显示保护模式状态（如果未隐藏）
+                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;
             }
-            // 显示票券信息
-            // @deprecated getCharge功能已在新API中移除，已注释
-            statusInfo += `\n\n🎫 票券情况: 此功能已在新API中移除`;
-            return statusInfo;
-        }
-        catch (error) {
-            ctx.logger('maibot').error('查询状态失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
+            catch (error) {
+                ctx.logger('maibot').error('查询状态失败:', error);
+                if (maintenanceMode) {
+                    return maintenanceMessage;
+                }
+                return `❌ 查询失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
             }
-            return `❌ 查询失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
+        });
     });
     /**
      * 锁定账号（登录保持）
@@ -1905,100 +2057,103 @@ function apply(ctx, config) {
         if (!Number.isInteger(multiple) || multiple < 2 || multiple > 6) {
             return '❌ 倍数必须是2-6之间的整数\n例如：/mai发票 3\n例如：/mai发票 6 @userid';
         }
-        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 withQueue(session, async () => {
+            try {
+                // 获取目标用户绑定
+                const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+                if (error || !binding) {
+                    return error || '❌ 获取用户绑定失败';
                 }
-            }
-            // 获取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绑定 重新绑定二维码`;
+                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 '操作已取消（第一次确认未通过）';
                     }
-                    // 重新绑定成功后，使用新的binding
-                    const updatedBinding = rebindResult.newBinding || binding;
-                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
-                    if (retryQrText.error) {
-                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
+                    if (!confirmSecond) {
+                        return '操作已取消（第二次确认未通过）';
                     }
-                    // 使用新的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 '❌ 发放功能票失败：服务器返回未成功，请稍后再试';
+                    if (multiple >= 3) {
+                        const confirmThird = await promptYesLocal(session, '第三次确认：3倍及以上票券风险更高，确定继续？');
+                        if (!confirmThird) {
+                            return '操作已取消（第三次确认未通过）';
+                        }
                     }
-                    return `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
                 }
-                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}`;
+                // 获取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请稍等几分钟在游戏内确认`;
                     }
-                    ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+                    return `❌ 获取二维码失败：${qrTextResult.error}`;
                 }
-                else {
-                    throw 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);
                 }
-            }
-            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 `✅ 重新绑定成功！请重新执行发票操作。`;
+                catch (error) {
+                    // 如果API返回失败，可能需要重新绑定
+                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                        // 重新绑定成功，重试获取功能票
+                        const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                        if (retryQrText.error) {
+                            return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                        }
+                        ticketResult = await api.getTicket(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, multiple, retryQrText.qrText);
+                    }
+                    else {
+                        throw error;
                     }
-                    return `❌ 发放功能票失败：服务器返回未成功\n重新绑定失败：${rebindResult.error || '未知错误'}`;
                 }
-                return '❌ 发票失败：服务器返回未成功，请确认是否已在短时间内多次执行发票指令或稍后再试或点击获取二维码刷新账号后再试。';
-            }
-            return `✅ 已发放 ${multiple} 倍票\n请稍等几分钟在游戏内确认`;
-        }
-        catch (error) {
-            logger.error('发票失败:', error);
-            if (maintenanceMode) {
-                return 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请稍等几分钟在游戏内确认`;
             }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${maintenanceMessage}`;
+            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}`;
             }
-            return `❌ 发票失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
+        });
     });
     /**
      * 舞里程发放 / 签到
@@ -2092,9 +2247,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 '❌ 无法获取会话信息';
         }
@@ -2103,109 +2259,145 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 检查是否已绑定水鱼Token
-            if (!binding.fishToken) {
-                return '❌ 请先绑定水鱼Token\n使用 /mai绑定水鱼 <token> 进行绑定';
-            }
-            // 维护时间内直接提示，不发起上传请求
-            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绑定 重新绑定二维码`;
+        // 使用队列系统
+        return withQueue(session, async () => {
+            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;
                     }
-                    // 重新绑定成功后，使用新的binding
-                    const updatedBinding = rebindResult.newBinding || binding;
-                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
-                    if (retryQrText.error) {
-                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    else {
+                        // 不是SGID，可能是targetUserId
+                        targetUserId = qrCodeOrTarget;
                     }
-                    // 使用新的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 { 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 {
+                        const preview = await api.getPreview(config.machineInfo.clientId, qrCode);
+                        if (preview.UserID === -1 || (typeof preview.UserID === 'string' && preview.UserID === '-1')) {
+                            return '❌ 无效或过期的二维码，请重新发送';
                         }
-                        const taskIdInfo = result.task_id ? `\n任务ID: ${result.task_id}` : '';
-                        return `❌ 上传失败：${result.msg || '未知错误'}${taskIdInfo}`;
+                        qrTextResult = { qrText: qrCode };
                     }
-                    scheduleB50Notification(session, result.task_id);
-                    return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
-                }
-                return `❌ 获取二维码失败：${qrTextResult.error}`;
-            }
-            // 上传B50（使用新API，需要qr_text）
-            let result;
-            try {
-                result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, binding.fishToken);
-            }
-            catch (error) {
-                // 如果API返回失败，可能需要重新绑定
-                const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                    // 重新绑定成功，重试上传
-                    const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
-                    if (retryQrText.error) {
-                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                    catch (error) {
+                        return `❌ 验证二维码失败：${error?.message || '未知错误'}`;
                     }
-                    result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
                 }
                 else {
-                    throw error;
+                    // 交互式获取
+                    qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
                 }
-            }
-            if (!result.UploadStatus) {
-                if (result.msg === '该账号下存在未完成的任务') {
-                    return '⚠️ 当前账号已有未完成的水鱼B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                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}`;
+                }
+                // 上传B50（使用新API，需要qr_text）
+                let result;
+                try {
+                    result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, binding.fishToken);
                 }
-                // 如果返回失败，可能需要重新绑定
-                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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                catch (error) {
+                    // 如果API返回失败，可能需要重新绑定
+                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                        // 重新绑定成功，重试上传
+                        const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                        if (retryQrText.error) {
+                            return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                        }
+                        result = await api.uploadB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, binding.fishToken);
+                    }
+                    else {
+                        throw error;
+                    }
+                }
+                if (!result.UploadStatus) {
+                    if (result.msg === '该账号下存在未完成的任务') {
+                        return '⚠️ 当前账号已有未完成的水鱼B50任务，请耐心等待任务完成，预计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分钟`;
-        }
-        catch (error) {
-            ctx.logger('maibot').error('上传B50失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
+                scheduleB50Notification(session, result.task_id);
+                return `✅ B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
             }
-            // 处理请求超时类错误，统一提示
-            if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
-                let msg = '水鱼B50任务 上传失败，请稍后再试一次。';
-                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
-                if (maintenanceMsg) {
-                    msg += `\n${maintenanceMsg}`;
+            catch (error) {
+                ctx.logger('maibot').error('上传B50失败:', error);
+                if (maintenanceMode) {
+                    return maintenanceMessage;
                 }
-                msg += `\n\n${maintenanceMessage}`;
-                return msg;
-            }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${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}`;
             }
-            return `❌ 上传失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
+        });
     });
     /**
      * 清空功能票
@@ -2654,9 +2846,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 '❌ 无法获取会话信息';
         }
@@ -2665,122 +2858,159 @@ function apply(ctx, config) {
         if (!whitelistCheck.allowed) {
             return whitelistCheck.message || '本群暂时没有被授权使用本Bot的功能，请添加官方群聊1072033605。';
         }
-        try {
-            // 获取目标用户绑定
-            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
-            if (error || !binding) {
-                return error || '❌ 获取用户绑定失败';
-            }
-            const userId = binding.userId;
-            // 确定使用的落雪代码
-            let finalLxnsCode;
-            if (lxnsCode) {
-                // 如果提供了参数，使用参数
-                // 验证落雪代码长度
-                if (lxnsCode.length !== 15) {
-                    return '❌ 落雪代码长度错误，必须为15个字符';
-                }
-                finalLxnsCode = lxnsCode;
-            }
-            else {
-                // 如果没有提供参数，使用绑定的代码
-                if (!binding.lxnsCode) {
-                    return '❌ 请先绑定落雪代码或提供落雪代码参数\n使用 /mai绑定落雪 <lxns_code> 进行绑定\n或使用 /mai上传落雪b50 <lxns_code> 直接提供代码';
-                }
-                finalLxnsCode = binding.lxnsCode;
-            }
-            // 维护时间内直接提示，不发起上传请求
-            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绑定 重新绑定二维码`;
+        // 使用队列系统
+        return withQueue(session, async () => {
+            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;
                     }
-                    // 重新绑定成功后，使用新的binding
-                    const updatedBinding = rebindResult.newBinding || binding;
-                    const retryQrText = await getQrText(session, ctx, api, updatedBinding, config, rebindTimeout);
-                    if (retryQrText.error) {
-                        return `❌ 获取二维码失败：${retryQrText.error}`;
+                    else if (qrCodeOrLxnsCode.length === 15) {
+                        // 可能是落雪代码（15个字符）
+                        lxnsCode = qrCodeOrLxnsCode;
                     }
-                    // 使用新的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}`;
+                    else {
+                        // 可能是targetUserId
+                        actualTargetUserId = qrCodeOrLxnsCode;
                     }
-                    scheduleLxB50Notification(session, result.task_id);
-                    return `✅ 落雪B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
                 }
-                return `❌ 获取二维码失败：${qrTextResult.error}`;
-            }
-            // 上传落雪B50（使用新API，需要qr_text）
-            let result;
-            try {
-                result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
-            }
-            catch (error) {
-                // 如果API返回失败，可能需要重新绑定
-                const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
-                if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
-                    // 重新绑定成功，重试上传
-                    const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
-                    if (retryQrText.error) {
-                        return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                // 获取目标用户绑定
+                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> 直接提供代码';
+                    }
+                    finalLxnsCode = binding.lxnsCode;
+                }
+                // 维护时间内直接提示，不发起上传请求
+                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
+                if (maintenanceMsg) {
+                    return maintenanceMsg;
+                }
+                // 获取qr_text（如果提供了SGID参数则直接使用，否则交互式获取）
+                let qrTextResult;
+                if (qrCode) {
+                    // 验证qrCode是否有效
+                    try {
+                        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) {
+                        return `❌ 验证二维码失败：${error?.message || '未知错误'}`;
                     }
-                    result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
                 }
                 else {
-                    throw error;
+                    // 交互式获取
+                    qrTextResult = await getQrText(session, ctx, api, binding, config, rebindTimeout);
                 }
-            }
-            if (!result.UploadStatus) {
-                if (result.msg === '该账号下存在未完成的任务') {
-                    return '⚠️ 当前账号已有未完成的落雪B50任务，请耐心等待任务完成，预计1-10分钟，无需重复上传。';
+                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}`;
+                }
+                // 上传落雪B50（使用新API，需要qr_text）
+                let result;
+                try {
+                    result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, qrTextResult.qrText, finalLxnsCode);
+                }
+                catch (error) {
+                    // 如果API返回失败，可能需要重新绑定
+                    const failureResult = await handleApiFailure(session, ctx, api, binding, config, error, rebindTimeout);
+                    if (failureResult.rebindResult && failureResult.rebindResult.success && failureResult.rebindResult.newBinding) {
+                        // 重新绑定成功，重试上传
+                        const retryQrText = await getQrText(session, ctx, api, failureResult.rebindResult.newBinding, config, rebindTimeout);
+                        if (retryQrText.error) {
+                            return `❌ 重新绑定后获取二维码失败：${retryQrText.error}`;
+                        }
+                        result = await api.uploadLxB50(machineInfo.regionId, machineInfo.clientId, machineInfo.placeId, retryQrText.qrText, finalLxnsCode);
+                    }
+                    else {
+                        throw error;
+                    }
                 }
-                // 如果返回失败，可能需要重新绑定
-                if (result.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 `✅ 重新绑定成功！请重新执行上传操作。`;
+                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 || '未知错误'}\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分钟`;
-        }
-        catch (error) {
-            ctx.logger('maibot').error('上传落雪B50失败:', error);
-            if (maintenanceMode) {
-                return maintenanceMessage;
+                scheduleLxB50Notification(session, result.task_id);
+                return `✅ 落雪B50上传任务已提交！\n任务ID: ${result.task_id}\n\n请耐心等待任务完成，预计1-10分钟`;
             }
-            // 处理请求超时类错误，统一提示
-            if (error?.code === 'ECONNABORTED' || String(error?.message || '').includes('timeout')) {
-                let msg = '落雪B50任务 上传失败，请稍后再试一次。';
-                const maintenanceMsg = getMaintenanceMessage(maintenanceNotice);
-                if (maintenanceMsg) {
-                    msg += `\n${maintenanceMsg}`;
+            catch (error) {
+                ctx.logger('maibot').error('上传落雪B50失败:', error);
+                if (maintenanceMode) {
+                    return maintenanceMessage;
                 }
-                msg += `\n\n${maintenanceMessage}`;
-                return msg;
-            }
-            if (error?.response) {
-                return `❌ API请求失败: ${error.response.status} ${error.response.statusText}\n\n${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}`;
             }
-            return `❌ 上传失败: ${error?.message || '未知错误'}\n\n${maintenanceMessage}`;
-        }
+        });
     });
     // 查询落雪B50任务状态功能已暂时取消
     /**