koishi-plugin-maibot 1.5.21 → 1.5.23

package/lib/index.js

@@ -41,6 +41,9 @@ exports.Config = koishi_1.Schema.object({
     lockRefreshDelay: koishi_1.Schema.number().default(1000).description('锁定账号刷新时每次 login 的延迟（毫秒），默认1秒（1000毫秒）'),
     lockRefreshConcurrency: koishi_1.Schema.number().default(3).description('锁定账号刷新时的并发数，默认3个账号同时刷新'),
     confirmTimeout: koishi_1.Schema.number().default(10000).description('确认提示超时时间（毫秒），默认10秒（10000毫秒）'),
+    protectionCheckInterval: koishi_1.Schema.number().default(60000).description('保护模式检查间隔（毫秒），默认60秒（60000毫秒）'),
+    authLevelForProxy: koishi_1.Schema.number().default(3).description('代操作功能需要的auth等级，默认3'),
+    protectionLockMessage: koishi_1.Schema.string().default('🛡️ 保护模式：{playerid}{at} 你的账号已自动锁定成功').description('保护模式锁定成功消息（支持占位符：{playerid} 玩家名，{at} @用户）'),
 });
 /**
  * 票券ID到中文名称的映射
@@ -286,6 +289,16 @@ function parseLoginStatus(isLogin) {
     }
     return false;
 }
+/**
+ * 从文本中提取用户ID（支持@userid格式或直接userid）
+ */
+function extractUserId(text) {
+    if (!text)
+        return null;
+    // 移除@符号和空格
+    const cleaned = text.trim().replace(/^@/, '');
+    return cleaned || null;
+}
 function apply(ctx, config) {
     // 扩展数据库
     (0, database_1.extendDatabase)(ctx);
@@ -306,6 +319,8 @@ function apply(ctx, config) {
     const turnstileToken = config.turnstileToken;
     const maintenanceNotice = config.maintenanceNotice;
     const confirmTimeout = config.confirmTimeout ?? 10000;
+    const authLevelForProxy = config.authLevelForProxy ?? 3;
+    const protectionLockMessage = config.protectionLockMessage ?? '🛡️ 保护模式：{playerid}{at} 你的账号已自动锁定成功';
     // 创建使用配置的 promptYes 函数
     const promptYesWithConfig = async (session, message, timeout) => {
         const actualTimeout = timeout ?? confirmTimeout;
@@ -321,6 +336,44 @@ function apply(ctx, config) {
     // 在 apply 函数内部使用 promptYesWithConfig 替代 promptYes
     // 为了简化，我们将直接修改所有调用，使用 promptYesWithConfig
     const promptYesLocal = promptYesWithConfig;
+    /**
+     * 从文本中提取用户ID（支持@userid格式或直接userid）
+     */
+    function extractUserId(text) {
+        if (!text)
+            return null;
+        // 移除@符号和空格
+        const cleaned = text.trim().replace(/^@/, '');
+        return cleaned || null;
+    }
+    /**
+     * 检查权限并获取目标用户绑定
+     * 如果提供了targetUserId，检查权限并使用目标用户
+     * 否则使用当前用户
+     */
+    async function getTargetBinding(session, targetUserIdText) {
+        const currentUserId = session.userId;
+        const targetUserIdRaw = extractUserId(targetUserIdText);
+        // 如果没有提供目标用户，使用当前用户
+        if (!targetUserIdRaw) {
+            const bindings = await ctx.database.get('maibot_bindings', { userId: currentUserId });
+            if (bindings.length === 0) {
+                return { binding: null, isProxy: false, error: '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定' };
+            }
+            return { binding: bindings[0], isProxy: false, error: null };
+        }
+        // 如果提供了目标用户，需要检查权限
+        const userAuthority = session.user?.authority ?? 0;
+        if (userAuthority < authLevelForProxy) {
+            return { binding: null, isProxy: true, error: `❌ 权限不足，需要auth等级${authLevelForProxy}以上才能代操作` };
+        }
+        // 获取目标用户的绑定
+        const bindings = await ctx.database.get('maibot_bindings', { userId: targetUserIdRaw });
+        if (bindings.length === 0) {
+            return { binding: null, isProxy: true, error: `❌ 用户 ${targetUserIdRaw} 尚未绑定账号` };
+        }
+        return { binding: bindings[0], isProxy: true, error: null };
+    }
     const scheduleB50Notification = (session, taskId) => {
         const bot = session.bot;
         const channelId = session.channelId;
@@ -525,21 +578,22 @@ function apply(ctx, config) {
     });
     /**
      * 查询绑定状态
-     * 用法: /mai状态 [--expired]
+     * 用法: /mai状态 [--expired] [@用户id]
      */
-    ctx.command('mai状态', '查询绑定状态')
+    ctx.command('mai状态 [targetUserId:text]', '查询绑定状态')
+        .userFields(['authority'])
         .option('expired', '--expired  显示过期票券')
-        .action(async ({ session, options }) => {
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 您还没有绑定账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             let statusInfo = `✅ 已绑定账号\n\n` +
                 `用户ID: ${maskUserId(binding.maiUid)}\n` +
                 `绑定时间: ${new Date(binding.bindTime).toLocaleString('zh-CN')}\n` +
@@ -581,6 +635,13 @@ function apply(ctx, config) {
             else {
                 statusInfo += `\n\n❄️ 落雪代码: 未绑定\n使用 /mai绑定落雪 <lxns_code> 进行绑定`;
             }
+            // 显示保护模式状态
+            if (binding.protectionMode) {
+                statusInfo += `\n\n🛡️ 保护模式: 已开启\n使用 /mai保护模式 off 关闭`;
+            }
+            else {
+                statusInfo += `\n\n🛡️ 保护模式: 未开启\n使用 /mai保护模式 on 开启（自动锁定已下线的账号）`;
+            }
             // 显示锁定状态（不显示LoginId）
             if (binding.isLocked) {
                 const lockTime = binding.lockTime
@@ -683,8 +744,10 @@ function apply(ctx, config) {
      * 锁定账号（登录保持）
      * 用法: /mai锁定
      */
-    ctx.command('mai锁定', '锁定账号，防止他人登录')
-        .action(async ({ session }) => {
+    ctx.command('mai锁定 [targetUserId:text]', '锁定账号，防止他人登录')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -703,9 +766,11 @@ function apply(ctx, config) {
                 return `⚠️ 账号已经锁定\n锁定时间: ${lockTime}\n使用 /mai解锁 可以解锁账号`;
             }
             // 确认操作
-            const confirm = await promptYesLocal(session, `⚠️ 即将锁定账号 ${maskUserId(binding.maiUid)}\n锁定后账号将保持登录状态，防止他人登录\n确认继续？`);
-            if (!confirm) {
-                return '操作已取消';
+            if (!options?.bypass) {
+                const confirm = await promptYesLocal(session, `⚠️ 即将锁定账号 ${maskUserId(binding.maiUid)}\n锁定后账号将保持登录状态，防止他人登录\n确认继续？`);
+                if (!confirm) {
+                    return '操作已取消';
+                }
             }
             await session.send('⏳ 正在锁定账号，请稍候...');
             // 调用登录API锁定账号
@@ -752,43 +817,53 @@ function apply(ctx, config) {
      * 解锁账号（登出）
      * 用法: /mai解锁
      */
-    ctx.command('mai解锁', '解锁账号（仅限通过mai锁定指令锁定的账号）')
+    ctx.command('mai解锁 [targetUserId:text]', '解锁账号（仅限通过mai锁定指令锁定的账号）')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
         .alias('mai逃离小黑屋')
         .alias('mai逃离')
-        .action(async ({ session }) => {
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 检查是否通过mai锁定指令锁定
             if (!binding.isLocked) {
                 return '⚠️ 账号未锁定\n\n目前只能解锁由 /mai锁定 指令发起的账户。\n其他登录暂时无法解锁。';
             }
             // 确认操作
-            const confirm = await promptYesLocal(session, `⚠️ 即将解锁账号 ${maskUserId(binding.maiUid)}\n确认继续？`);
-            if (!confirm) {
-                return '操作已取消';
+            if (!options?.bypass) {
+                const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
+                const confirm = await promptYesLocal(session, `⚠️ 即将解锁账号 ${maskUserId(binding.maiUid)}${proxyTip}\n确认继续？`);
+                if (!confirm) {
+                    return '操作已取消';
+                }
             }
             await session.send('⏳ 正在解锁账号，请稍候...');
             const result = await api.logout(binding.maiUid, machineInfo.regionId.toString(), machineInfo.clientId, machineInfo.placeId.toString(), turnstileToken);
             if (!result.LogoutStatus) {
                 return '❌ 解锁失败，服务端未返回成功状态，请稍后重试';
             }
-            // 清除锁定信息
+            // 清除锁定信息（如果开启了保护模式，不关闭保护模式，让它继续监控）
             await ctx.database.set('maibot_bindings', { userId }, {
                 isLocked: false,
                 lockTime: null,
                 lockLoginId: null,
             });
-            return `✅ 账号已解锁\n` +
+            let message = `✅ 账号已解锁\n` +
                 `用户ID: ${maskUserId(binding.maiUid)}\n` +
                 `建议稍等片刻再登录`;
+            // 如果开启了保护模式，提示用户保护模式会继续监控
+            if (binding.protectionMode) {
+                message += `\n\n🛡️ 保护模式仍开启，系统会在检测到账号下线时自动尝试锁定`;
+            }
+            return message;
         }
         catch (error) {
             logger.error('解锁账号失败:', error);
@@ -802,8 +877,9 @@ function apply(ctx, config) {
      * 绑定水鱼Token
      * 用法: /mai绑定水鱼 <fishToken>
      */
-    ctx.command('mai绑定水鱼 <fishToken:text>', '绑定水鱼Token用于B50上传')
-        .action(async ({ session }, fishToken) => {
+    ctx.command('mai绑定水鱼 <fishToken:text> [targetUserId:text]', '绑定水鱼Token用于B50上传')
+        .userFields(['authority'])
+        .action(async ({ session }, fishToken, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -814,13 +890,13 @@ function apply(ctx, config) {
         if (fishToken.length < 127 || fishToken.length > 132) {
             return '❌ Token长度错误，应在127-132字符之间';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
+            const userId = binding.userId;
             // 更新水鱼Token
             await ctx.database.set('maibot_bindings', { userId }, {
                 fishToken,
@@ -836,19 +912,19 @@ function apply(ctx, config) {
      * 解绑水鱼Token
      * 用法: /mai解绑水鱼
      */
-    ctx.command('mai解绑水鱼', '解绑水鱼Token（保留舞萌DX账号绑定）')
-        .action(async ({ session }) => {
+    ctx.command('mai解绑水鱼 [targetUserId:text]', '解绑水鱼Token（保留舞萌DX账号绑定）')
+        .userFields(['authority'])
+        .action(async ({ session }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 检查是否已绑定水鱼Token
             if (!binding.fishToken) {
                 return '❌ 您还没有绑定水鱼Token\n使用 /mai绑定水鱼 <token> 进行绑定';
@@ -868,8 +944,9 @@ function apply(ctx, config) {
      * 绑定落雪代码
      * 用法: /mai绑定落雪 <lxnsCode>
      */
-    ctx.command('mai绑定落雪 <lxnsCode:text>', '绑定落雪代码用于B50上传')
-        .action(async ({ session }, lxnsCode) => {
+    ctx.command('mai绑定落雪 <lxnsCode:text> [targetUserId:text]', '绑定落雪代码用于B50上传')
+        .userFields(['authority'])
+        .action(async ({ session }, lxnsCode, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -880,13 +957,13 @@ function apply(ctx, config) {
         if (lxnsCode.length !== 15) {
             return '❌ 落雪代码长度错误，必须为15个字符';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
+            const userId = binding.userId;
             // 更新落雪代码
             await ctx.database.set('maibot_bindings', { userId }, {
                 lxnsCode,
@@ -902,19 +979,19 @@ function apply(ctx, config) {
      * 解绑落雪代码
      * 用法: /mai解绑落雪
      */
-    ctx.command('mai解绑落雪', '解绑落雪代码（保留舞萌DX账号绑定）')
-        .action(async ({ session }) => {
+    ctx.command('mai解绑落雪 [targetUserId:text]', '解绑落雪代码（保留舞萌DX账号绑定）')
+        .userFields(['authority'])
+        .action(async ({ session }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 检查是否已绑定落雪代码
             if (!binding.lxnsCode) {
                 return '❌ 您还没有绑定落雪代码\n使用 /mai绑定落雪 <lxns_code> 进行绑定';
@@ -932,37 +1009,43 @@ function apply(ctx, config) {
     });
     /**
      * 发票（2-6倍票）
-     * 用法: /mai发票 [倍数]，默认2
+     * 用法: /mai发票 [倍数] [@用户id]，默认2
      */
-    ctx.command('mai发票 [multiple:number]', '为账号发放功能票（2-6倍）')
-        .action(async ({ session }, multipleInput) => {
+    ctx.command('mai发票 [multiple:number] [targetUserId:text]', '为账号发放功能票（2-6倍）')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, multipleInput, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
         const multiple = multipleInput ? Number(multipleInput) : 2;
         if (!Number.isInteger(multiple) || multiple < 2 || multiple > 6) {
-            return '❌ 倍数必须是2-6之间的整数\n例如：/mai发票 3';
+            return '❌ 倍数必须是2-6之间的整数\n例如：/mai发票 3\n例如：/mai发票 6 @userid';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
-            }
-            const binding = bindings[0];
-            const baseTip = `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放 ${multiple} 倍票`;
-            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 '操作已取消（第三次确认未通过）';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
+            // 确认操作（如果未使用 -bypass）
+            if (!options?.bypass) {
+                const baseTip = `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放 ${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 '操作已取消（第三次确认未通过）';
+                    }
                 }
             }
             await session.send('⏳ 已开始请求发票，服务器响应可能需要约10秒，请耐心等待...');
@@ -986,8 +1069,10 @@ function apply(ctx, config) {
      * 舞里程发放 / 签到
      * 用法: /mai舞里程 <里程数>
      */
-    ctx.command('mai舞里程 <mile:number>', '为账号发放舞里程（maimile）')
-        .action(async ({ session }, mileInput) => {
+    ctx.command('mai舞里程 <mile:number> [targetUserId:text]', '为账号发放舞里程（maimile）')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, mileInput, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
@@ -1002,21 +1087,25 @@ function apply(ctx, config) {
         if (mile >= 99999) {
             return '❌ 舞里程过大，请控制在 99999 以下';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
-            }
-            const binding = bindings[0];
-            const baseTip = `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放 ${mile} 点舞里程`;
-            const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
-            if (!confirmFirst) {
-                return '操作已取消（第一次确认未通过）';
-            }
-            const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
-            if (!confirmSecond) {
-                return '操作已取消（第二次确认未通过）';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
+            // 确认操作（如果未使用 -bypass）
+            if (!options?.bypass) {
+                const baseTip = `⚠️ 即将为 ${maskUserId(binding.maiUid)} 发放 ${mile} 点舞里程${proxyTip}`;
+                const confirmFirst = await promptYesLocal(session, `${baseTip}\n操作具有风险，请谨慎`);
+                if (!confirmFirst) {
+                    return '操作已取消（第一次确认未通过）';
+                }
+                const confirmSecond = await promptYesLocal(session, '二次确认：若理解风险，请再次输入 Y 执行');
+                if (!confirmSecond) {
+                    return '操作已取消（第二次确认未通过）';
+                }
             }
             await session.send('⏳ 已开始请求发放舞里程，服务器响应可能需要数秒，请耐心等待...');
             const result = await api.maimile(binding.maiUid, mile, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
@@ -1040,21 +1129,21 @@ function apply(ctx, config) {
     });
     /**
      * 上传B50到水鱼
-     * 用法: /mai上传B50
+     * 用法: /mai上传B50 [@用户id]
      */
-    ctx.command('mai上传B50', '上传B50数据到水鱼')
-        .action(async ({ session }) => {
+    ctx.command('mai上传B50 [targetUserId:text]', '上传B50数据到水鱼')
+        .userFields(['authority'])
+        .action(async ({ session }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 检查是否已绑定水鱼Token
             if (!binding.fishToken) {
                 return '❌ 请先绑定水鱼Token\n使用 /mai绑定水鱼 <token> 进行绑定';
@@ -1096,21 +1185,27 @@ function apply(ctx, config) {
      * 清空功能票
      * 用法: /mai清票
      */
-    ctx.command('mai清票', '清空账号的所有功能票')
-        .action(async ({ session }) => {
+    ctx.command('mai清票 [targetUserId:text]', '清空账号的所有功能票')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
-            }
-            const binding = bindings[0];
-            const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的所有功能票，确认继续？`);
-            if (!confirm) {
-                return '操作已取消';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            const proxyTip = isProxy ? `（代操作用户 ${userId}）` : '';
+            // 确认操作（如果未使用 -bypass）
+            if (!options?.bypass) {
+                const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的所有功能票${proxyTip}，确认继续？`);
+                if (!confirm) {
+                    return '操作已取消';
+                }
             }
             const result = await api.clearTicket(binding.maiUid, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
             // 检查4个状态字段是否都是 true
@@ -1145,19 +1240,19 @@ function apply(ctx, config) {
      * 查询B50任务状态
      * 用法: /mai查询B50
      */
-    ctx.command('mai查询B50', '查询B50上传任务状态')
-        .action(async ({ session }) => {
+    ctx.command('mai查询B50 [targetUserId:text]', '查询B50上传任务状态')
+        .userFields(['authority'])
+        .action(async ({ session }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 查询任务状态
             const taskStatus = await api.getB50TaskStatus(binding.maiUid);
             if (taskStatus.code !== 0 || !taskStatus.alive_task_id) {
@@ -1194,18 +1289,20 @@ function apply(ctx, config) {
      * 发收藏品
      * 用法: /mai发收藏品
      */
-    ctx.command('mai发收藏品', '发放收藏品')
-        .action(async ({ session }) => {
+    ctx.command('mai发收藏品 [targetUserId:text]', '发放收藏品')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 交互式选择收藏品类别
             const itemKind = await promptCollectionType(session);
             if (itemKind === null) {
@@ -1249,18 +1346,20 @@ function apply(ctx, config) {
      * 清收藏品
      * 用法: /mai清收藏品
      */
-    ctx.command('mai清收藏品', '清空收藏品')
-        .action(async ({ session }) => {
+    ctx.command('mai清收藏品 [targetUserId:text]', '清空收藏品')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 交互式选择收藏品类别
             const itemKind = await promptCollectionType(session);
             if (itemKind === null) {
@@ -1281,9 +1380,12 @@ function apply(ctx, config) {
             if (!/^\d+$/.test(itemId)) {
                 return '❌ ID必须是数字，请重新输入';
             }
-            const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的收藏品\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`);
-            if (!confirm) {
-                return '操作已取消';
+            // 确认操作（如果未使用 -bypass）
+            if (!options?.bypass) {
+                const confirm = await promptYesLocal(session, `⚠️ 即将清空 ${maskUserId(binding.maiUid)} 的收藏品\n类型: ${selectedType?.label} (${itemKind})\nID: ${itemId}\n确认继续？`);
+                if (!confirm) {
+                    return '操作已取消';
+                }
             }
             await session.send('⏳ 正在清空收藏品，请稍候...');
             const result = await api.clearItem(binding.maiUid, itemId, itemKind.toString(), machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName);
@@ -1304,18 +1406,20 @@ function apply(ctx, config) {
      * 上传乐曲成绩
      * 用法: /mai上传乐曲成绩
      */
-    ctx.command('mai上传乐曲成绩', '上传游戏乐曲成绩')
-        .action(async ({ session }) => {
+    ctx.command('mai上传乐曲成绩 [targetUserId:text]', '上传游戏乐曲成绩')
+        .userFields(['authority'])
+        .option('bypass', '-bypass  绕过确认')
+        .action(async ({ session, options }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 交互式输入乐曲成绩数据
             const scoreData = await promptScoreData(session);
             if (!scoreData) {
@@ -1324,16 +1428,19 @@ function apply(ctx, config) {
             const levelLabel = LEVEL_OPTIONS.find(opt => opt.value === scoreData.level)?.label || scoreData.level.toString();
             const fcLabel = FC_STATUS_OPTIONS.find(opt => opt.value === scoreData.fcStatus)?.label || scoreData.fcStatus.toString();
             const syncLabel = SYNC_STATUS_OPTIONS.find(opt => opt.value === scoreData.syncStatus)?.label || scoreData.syncStatus.toString();
-            const confirm = await promptYesLocal(session, `⚠️ 即将为 ${maskUserId(binding.maiUid)} 上传乐曲成绩\n` +
-                `乐曲ID: ${scoreData.musicId}\n` +
-                `难度等级: ${levelLabel} (${scoreData.level})\n` +
-                `达成率: ${scoreData.achievement}\n` +
-                `Full Combo: ${fcLabel} (${scoreData.fcStatus})\n` +
-                `同步状态: ${syncLabel} (${scoreData.syncStatus})\n` +
-                `DX分数: ${scoreData.dxScore}\n` +
-                `确认继续？`);
-            if (!confirm) {
-                return '操作已取消';
+            // 确认操作（如果未使用 -bypass）
+            if (!options?.bypass) {
+                const confirm = await promptYesLocal(session, `⚠️ 即将为 ${maskUserId(binding.maiUid)} 上传乐曲成绩\n` +
+                    `乐曲ID: ${scoreData.musicId}\n` +
+                    `难度等级: ${levelLabel} (${scoreData.level})\n` +
+                    `达成率: ${scoreData.achievement}\n` +
+                    `Full Combo: ${fcLabel} (${scoreData.fcStatus})\n` +
+                    `同步状态: ${syncLabel} (${scoreData.syncStatus})\n` +
+                    `DX分数: ${scoreData.dxScore}\n` +
+                    `确认继续？`);
+                if (!confirm) {
+                    return '操作已取消';
+                }
             }
             await session.send('⏳ 正在上传乐曲成绩，请稍候...');
             const result = await api.uploadScore(binding.maiUid, machineInfo.clientId, machineInfo.regionId, machineInfo.placeId, machineInfo.placeName, machineInfo.regionName, scoreData.musicId, scoreData.level, scoreData.achievement, scoreData.fcStatus, scoreData.syncStatus, scoreData.dxScore);
@@ -1369,21 +1476,21 @@ function apply(ctx, config) {
     });
     /**
      * 上传落雪B50
-     * 用法: /mai上传落雪b50 [lxns_code]
+     * 用法: /mai上传落雪b50 [lxns_code] [@用户id]
      */
-    ctx.command('mai上传落雪b50 [lxnsCode:text]', '上传B50数据到落雪')
-        .action(async ({ session }, lxnsCode) => {
+    ctx.command('mai上传落雪b50 [lxnsCode:text] [targetUserId:text]', '上传B50数据到落雪')
+        .userFields(['authority'])
+        .action(async ({ session }, lxnsCode, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 确定使用的落雪代码
             let finalLxnsCode;
             if (lxnsCode) {
@@ -1438,19 +1545,19 @@ function apply(ctx, config) {
      * 查询落雪B50任务状态
      * 用法: /mai查询落雪B50
      */
-    ctx.command('mai查询落雪B50', '查询落雪B50上传任务状态')
-        .action(async ({ session }) => {
+    ctx.command('mai查询落雪B50 [targetUserId:text]', '查询落雪B50上传任务状态')
+        .userFields(['authority'])
+        .action(async ({ session }, targetUserId) => {
         if (!session) {
             return '❌ 无法获取会话信息';
         }
-        const userId = session.userId;
         try {
-            // 检查是否已绑定账号
-            const bindings = await ctx.database.get('maibot_bindings', { userId });
-            if (bindings.length === 0) {
-                return '❌ 请先绑定舞萌DX账号\n使用 /mai绑定 <SGWCMAID...> 进行绑定';
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
             }
-            const binding = bindings[0];
+            const userId = binding.userId;
             // 查询任务状态
             const taskStatus = await api.getLxB50TaskStatus(binding.maiUid);
             if (taskStatus.code !== 0 || !taskStatus.alive_task_id) {
@@ -1775,6 +1882,149 @@ function apply(ctx, config) {
         logger.info('执行首次锁定账号刷新...');
         refreshLockedAccounts();
     }, 30000); // 30秒后执行首次刷新
+    /**
+     * 保护模式：自动锁定单个账号（当检测到下线时）
+     */
+    const autoLockAccount = async (binding) => {
+        // 检查插件是否还在运行
+        if (!isPluginActive) {
+            logger.debug('插件已停止，跳过自动锁定检查');
+            return;
+        }
+        try {
+            // 再次检查账号是否仍在保护模式下且未锁定
+            const currentBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
+            if (currentBinding.length === 0 || !currentBinding[0].protectionMode || currentBinding[0].isLocked) {
+                logger.debug(`用户 ${binding.userId} 保护模式已关闭或账号已锁定，跳过自动锁定检查`);
+                return;
+            }
+            // 再次检查插件状态
+            if (!isPluginActive) {
+                logger.debug('插件已停止，取消预览请求');
+                return;
+            }
+            logger.debug(`保护模式：检查用户 ${binding.userId} (maiUid: ${maskUserId(binding.maiUid)}) 的登录状态`);
+            // 获取当前登录状态
+            const preview = await api.preview(binding.maiUid);
+            const currentLoginStatus = parseLoginStatus(preview.IsLogin);
+            logger.debug(`用户 ${binding.userId} 当前登录状态: ${currentLoginStatus}`);
+            // 如果账号已下线，尝试自动锁定
+            if (!currentLoginStatus) {
+                logger.info(`保护模式：检测到用户 ${binding.userId} 账号已下线，尝试自动锁定`);
+                // 再次确认账号状态和插件状态
+                const verifyBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
+                if (verifyBinding.length === 0 || !verifyBinding[0].protectionMode || verifyBinding[0].isLocked) {
+                    logger.debug(`用户 ${binding.userId} 保护模式已关闭或账号已锁定，取消自动锁定`);
+                    return;
+                }
+                if (!isPluginActive) {
+                    logger.debug('插件已停止，取消自动锁定请求');
+                    return;
+                }
+                // 执行锁定
+                const result = await api.login(binding.maiUid, machineInfo.regionId, machineInfo.placeId, machineInfo.clientId, turnstileToken);
+                if (result.LoginStatus) {
+                    // 锁定成功，更新数据库
+                    await ctx.database.set('maibot_bindings', { userId: binding.userId }, {
+                        isLocked: true,
+                        lockTime: new Date(),
+                        lockLoginId: result.LoginId,
+                    });
+                    logger.info(`保护模式：用户 ${binding.userId} 账号已自动锁定成功，LoginId: ${result.LoginId}`);
+                    // 发送@用户通知
+                    const finalBinding = await ctx.database.get('maibot_bindings', { userId: binding.userId });
+                    if (finalBinding.length > 0 && finalBinding[0].guildId && finalBinding[0].channelId) {
+                        try {
+                            // 获取玩家名
+                            // 获取玩家名
+                            const playerName = preview.UserName || binding.userName || '玩家';
+                            const mention = `<at id="${binding.userId}"/>`;
+                            // 使用配置的消息模板
+                            const message = protectionLockMessage
+                                .replace(/{playerid}/g, playerName)
+                                .replace(/{at}/g, mention);
+                            // 尝试使用第一个可用的bot发送消息
+                            let sent = false;
+                            for (const bot of ctx.bots) {
+                                try {
+                                    await bot.sendMessage(finalBinding[0].channelId, message, finalBinding[0].guildId);
+                                    logger.info(`✅ 已发送保护模式锁定成功通知给用户 ${binding.userId} (${playerName})`);
+                                    sent = true;
+                                    break; // 成功发送后退出循环
+                                }
+                                catch (error) {
+                                    logger.warn(`bot ${bot.selfId} 发送保护模式通知失败:`, error);
+                                    continue;
+                                }
+                            }
+                            if (!sent) {
+                                logger.error(`❌ 所有bot都无法发送保护模式通知给用户 ${binding.userId}`);
+                            }
+                        }
+                        catch (error) {
+                            logger.error(`发送保护模式通知失败:`, error);
+                        }
+                    }
+                }
+                else {
+                    logger.warn(`保护模式：用户 ${binding.userId} 自动锁定失败，将在下次检查时重试`);
+                    if (result.UserID === -2) {
+                        logger.error(`保护模式：用户 ${binding.userId} 自动锁定失败：Turnstile校验失败`);
+                    }
+                }
+            }
+            else {
+                logger.debug(`保护模式：用户 ${binding.userId} 账号仍在线上，无需锁定`);
+            }
+        }
+        catch (error) {
+            logger.error(`保护模式：检查用户 ${binding.userId} 状态失败:`, error);
+        }
+    };
+    /**
+     * 保护模式：检查所有启用保护模式的账号，自动锁定已下线的账号
+     */
+    const checkProtectionMode = async () => {
+        // 检查插件是否还在运行
+        if (!isPluginActive) {
+            logger.debug('插件已停止，取消保护模式检查任务');
+            return;
+        }
+        logger.debug('开始检查保护模式账号...');
+        try {
+            // 获取所有启用保护模式且未锁定的账号
+            const allBindings = await ctx.database.get('maibot_bindings', {});
+            logger.debug(`总共有 ${allBindings.length} 个绑定记录`);
+            // 过滤出启用保护模式且未锁定的账号
+            const bindings = allBindings.filter(b => {
+                return b.protectionMode === true && b.isLocked !== true;
+            });
+            logger.debug(`启用保护模式的账号数量: ${bindings.length}`);
+            if (bindings.length > 0) {
+                logger.debug(`启用保护模式的账号列表: ${bindings.map(b => `${b.userId}(${maskUserId(b.maiUid)})`).join(', ')}`);
+            }
+            if (bindings.length === 0) {
+                logger.debug('没有启用保护模式的账号，跳过检查');
+                return;
+            }
+            // 使用并发处理
+            logger.debug(`使用并发数 ${concurrency} 检查 ${bindings.length} 个保护模式账号`);
+            await processBatch(bindings, concurrency, autoLockAccount);
+        }
+        catch (error) {
+            logger.error('检查保护模式账号失败:', error);
+        }
+        logger.debug('保护模式检查完成');
+    };
+    // 启动保护模式检查定时任务，使用配置的间隔
+    const protectionCheckInterval = config.protectionCheckInterval ?? 60000; // 默认60秒
+    logger.info(`账号保护模式检查功能已启动，检查间隔: ${protectionCheckInterval}ms (${protectionCheckInterval / 1000}秒)，并发数: ${concurrency}`);
+    ctx.setInterval(checkProtectionMode, protectionCheckInterval);
+    // 立即执行一次检查（延迟35秒，避免与其他检查冲突）
+    ctx.setTimeout(() => {
+        logger.info('执行首次保护模式检查...');
+        checkProtectionMode();
+    }, 35000); // 35秒后执行首次检查
     /**
      * 开关播报功能
      * 用法: /maialert [on|off]
@@ -1918,5 +2168,87 @@ function apply(ctx, config) {
             return `❌ 操作失败: ${error?.message || '未知错误'}`;
         }
     });
+    /**
+     * 开关账号保护模式
+     * 用法: /mai保护模式 [on|off]
+     */
+    ctx.command('mai保护模式 [state:text] [targetUserId:text]', '开关账号保护模式（自动锁定已下线的账号）')
+        .userFields(['authority'])
+        .action(async ({ session }, state, targetUserId) => {
+        if (!session) {
+            return '❌ 无法获取会话信息';
+        }
+        try {
+            // 获取目标用户绑定
+            const { binding, isProxy, error } = await getTargetBinding(session, targetUserId);
+            if (error || !binding) {
+                return error || '❌ 获取用户绑定失败';
+            }
+            const userId = binding.userId;
+            const currentState = binding.protectionMode ?? false;
+            // 如果没有提供参数，显示当前状态
+            if (!state) {
+                return `当前保护模式状态: ${currentState ? '✅ 已开启' : '❌ 已关闭'}\n\n使用 /mai保护模式 on 开启\n使用 /mai保护模式 off 关闭\n\n开启后会自动锁定账号，如果锁定失败会在账号下线时自动尝试锁定`;
+            }
+            const newState = state.toLowerCase() === 'on' || state.toLowerCase() === 'true' || state === '1';
+            // 如果状态没有变化
+            if (currentState === newState) {
+                return `保护模式已经是 ${newState ? '开启' : '关闭'} 状态`;
+            }
+            logger.info(`用户 ${userId} ${newState ? '开启' : '关闭'}保护模式`);
+            if (newState) {
+                // 开启保护模式：尝试立即锁定账号
+                if (binding.isLocked) {
+                    // 如果已经锁定，直接开启保护模式
+                    await ctx.database.set('maibot_bindings', { userId }, {
+                        protectionMode: true,
+                    });
+                    return `✅ 保护模式已开启\n账号当前已锁定，保护模式将在账号解锁后生效`;
+                }
+                // 尝试锁定账号
+                await session.send('⏳ 正在尝试锁定账号，请稍候...');
+                const result = await api.login(binding.maiUid, machineInfo.regionId, machineInfo.placeId, machineInfo.clientId, turnstileToken);
+                const updateData = {
+                    protectionMode: true,
+                };
+                if (result.LoginStatus) {
+                    // 锁定成功
+                    updateData.isLocked = true;
+                    updateData.lockTime = new Date();
+                    updateData.lockLoginId = result.LoginId;
+                    // 如果之前开启了推送，锁定时自动关闭
+                    if (binding.alertEnabled === true) {
+                        updateData.alertEnabled = false;
+                        logger.info(`用户 ${userId} 保护模式锁定账号，已自动关闭 maialert 推送`);
+                    }
+                    await ctx.database.set('maibot_bindings', { userId }, updateData);
+                    return `✅ 保护模式已开启\n账号已成功锁定，将保持登录状态防止他人登录`;
+                }
+                else {
+                    // 锁定失败，但仍开启保护模式，系统会在账号下线时自动尝试锁定
+                    await ctx.database.set('maibot_bindings', { userId }, updateData);
+                    let message = `✅ 保护模式已开启\n⚠️ 当前无法锁定账号（可能账号正在被使用或者挂哥上号）\n系统将定期检查账号状态，当检测到账号下线时会自动尝试锁定，防止一直小黑屋！\n`;
+                    if (result.UserID === -2) {
+                        message += `\n错误信息：Turnstile校验失败`;
+                    }
+                    else {
+                        message += `\n错误信息：服务端未返回成功状态`;
+                    }
+                    return message;
+                }
+            }
+            else {
+                // 关闭保护模式
+                await ctx.database.set('maibot_bindings', { userId }, {
+                    protectionMode: false,
+                });
+                return `✅ 保护模式已关闭\n已停止自动锁定功能`;
+            }
+        }
+        catch (error) {
+            logger.error('开关保护模式失败:', error);
+            return `❌ 操作失败: ${error?.message || '未知错误'}`;
+        }
+    });
 }
 //# sourceMappingURL=index.js.map