koishi-plugin-onebot-group-manage 0.0.2 → 0.0.3

package/lib/index.js

@@ -32,187 +32,450 @@ var ROLE_QUERY_TIMEOUT = 1e4;
 var roleCache = /* @__PURE__ */ new Map();
 var actionSchema = import_koishi.Schema.object({
   requireGroupAdmin: import_koishi.Schema.boolean().default(true).description("调用者必须是群管/群主"),
-  minAuthority: import_koishi.Schema.number().min(0).default(1).description("调用者最低 Koishi 权限，0 表示不校验")
+  minAuthority: import_koishi.Schema.number().min(0).default(1).description("调用者最低 Koishi 权限，为 0 表示不校验")
 });
 var Config = import_koishi.Schema.object({
   mute: actionSchema.description("禁言配置"),
   unmute: actionSchema.description("解禁配置"),
   kick: actionSchema.description("踢人配置"),
-  title: actionSchema.description("头衔配置"),
+  title: actionSchema.description("头衔配置（机器人需要群主权限）"),
   selfMute: import_koishi.Schema.object({
-    minSeconds: import_koishi.Schema.number().min(1).default(60).description("随机禁言最小秒数"),
-    maxSeconds: import_koishi.Schema.number().min(1).default(600).description("随机禁言最大秒数")
-  }).description("禁言我配置"),
+    minSeconds: import_koishi.Schema.number().min(1).default(60).description("“禁言我”随机最小秒数"),
+    maxSeconds: import_koishi.Schema.number().min(1).default(600).description("“禁言我”随机最大秒数")
+  }).description("自助禁言配置"),
   debug: import_koishi.Schema.object({
-    verbose: import_koishi.Schema.boolean().default(false)
-  }).default({ verbose: false })
+    verbose: import_koishi.Schema.boolean().default(false).description("开启详细日志（仅建议排查问题时启用）")
+  }).default({ verbose: false }).description("调试选项")
 });
-function withTimeout(p, ms) {
+function toCamel(action) {
+  return action.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+__name(toCamel, "toCamel");
+function withTimeout(p, ms, label) {
   return Promise.race([
     p,
-    new Promise((_, r) => setTimeout(() => r(new Error(`timeout ${ms}ms`)), ms))
+    new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timeout (${ms}ms)`)), ms))
   ]);
 }
 __name(withTimeout, "withTimeout");
 function getBotOnebot(bot) {
-  return bot?.onebot || bot?.internal?.onebot || bot?.internal || null;
+  const direct = bot?.onebot || bot?.internal?.onebot;
+  if (direct) return direct;
+  const internal = bot?.internal;
+  if (internal && (internal.setGroupBan || internal.set_group_ban || internal.callApi)) return internal;
+  return null;
 }
 __name(getBotOnebot, "getBotOnebot");
-function randomInt(min, max) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
+async function callOneBotApi(bot, action, params, onebotOverride) {
+  const gid = params?.group_id ?? params?.groupId ?? params?.group?.id;
+  const uid = params?.user_id ?? params?.userId ?? params?.user?.id;
+  const payload = {
+    ...params,
+    group_id: gid != null ? Number(gid) : gid,
+    user_id: uid != null ? Number(uid) : uid
+  };
+  const ob = onebotOverride || getBotOnebot(bot);
+  if (ob) {
+    switch (action) {
+      case "get_group_member_info": {
+        if (typeof ob.getGroupMemberInfo === "function") {
+          return ob.getGroupMemberInfo(Number(payload.group_id), Number(payload.user_id), Boolean(payload.no_cache));
+        }
+        break;
+      }
+      case "set_group_ban": {
+        if (typeof ob.callApi === "function") return ob.callApi("set_group_ban", payload);
+        if (typeof ob.setGroupBan === "function") {
+          return ob.setGroupBan(Number(payload.group_id), Number(payload.user_id), Number(payload.duration ?? 0));
+        }
+        break;
+      }
+      case "set_group_kick": {
+        if (typeof ob.callApi === "function") return ob.callApi("set_group_kick", payload);
+        if (typeof ob.setGroupKick === "function") {
+          return ob.setGroupKick(Number(payload.group_id), Number(payload.user_id), Boolean(payload.reject_add_request));
+        }
+        break;
+      }
+      case "set_group_special_title": {
+        if (typeof ob.callApi === "function") return ob.callApi("set_group_special_title", payload);
+        if (typeof ob.setGroupSpecialTitle === "function") {
+          return ob.setGroupSpecialTitle(
+            Number(payload.group_id),
+            Number(payload.user_id),
+            payload.special_title ?? "",
+            Number(payload.duration ?? -1)
+          );
+        }
+        break;
+      }
+      default: {
+        if (typeof ob[action] === "function") return ob[action](payload);
+        const camel = toCamel(action);
+        if (typeof ob[camel] === "function") return ob[camel](payload);
+        if (typeof ob.callApi === "function") return ob.callApi(action, payload);
+      }
+    }
+  }
+  throw new Error("onebot instance not available on bot");
 }
-__name(randomInt, "randomInt");
-async function getMemberRole(probe, bot, guildId, userId, logger, verbose) {
-  const key = `${bot.selfId}:${guildId}:${userId}`;
+__name(callOneBotApi, "callOneBotApi");
+function botKey(bot) {
+  return bot?.sid || `${bot?.platform || "onebot"}:${bot?.selfId || ""}`;
+}
+__name(botKey, "botKey");
+async function getMemberRole(probeOnebot, targetBot, guildId, userId, logger, verbose) {
+  const key = `${botKey(targetBot)}::${guildId}::${userId}`;
   const cached = roleCache.get(key);
   if (cached && cached.expire > Date.now()) return cached.role;
   try {
-    const info = await withTimeout(
-      probe.getGroupMemberInfo(Number(guildId), Number(userId), false),
-      ROLE_QUERY_TIMEOUT
-    );
+    const direct = probeOnebot?.getGroupMemberInfo;
+    let info = null;
+    if (typeof direct === "function") {
+      info = await withTimeout(
+        direct.call(probeOnebot, Number(guildId), Number(userId), false),
+        ROLE_QUERY_TIMEOUT,
+        "get_group_member_info"
+      );
+    } else {
+      info = await withTimeout(
+        callOneBotApi(targetBot, "get_group_member_info", {
+          group_id: Number(guildId),
+          user_id: Number(userId),
+          no_cache: false
+        }, probeOnebot),
+        ROLE_QUERY_TIMEOUT,
+        "get_group_member_info"
+      );
+    }
     const role = info?.role ?? null;
-    if (role) roleCache.set(key, { role, expire: Date.now() + ROLE_CACHE_TTL });
+    if (role) {
+      roleCache.set(key, { role, expire: Date.now() + ROLE_CACHE_TTL });
+      logger?.[verbose ? "info" : "debug"](
+        `get_group_member_info ok bot=${botKey(targetBot)} guild=${guildId} user=${userId} role=${role}`
+      );
+    } else {
+      logger?.[verbose ? "warn" : "debug"](
+        `get_group_member_info empty bot=${botKey(targetBot)} guild=${guildId} user=${userId}`
+      );
+    }
     return role;
-  } catch {
+  } catch (error) {
+    logger?.[verbose ? "warn" : "debug"](error, `get_group_member_info failed bot=${botKey(targetBot)} guild=${guildId} user=${userId}`);
     return null;
   }
 }
 __name(getMemberRole, "getMemberRole");
-async function verifyCaller(session, rule) {
+async function verifyCaller(session, rule, logger, verbose) {
   const authority = Number(session.user?.authority ?? 0);
   if (!rule.requireGroupAdmin && rule.minAuthority <= 0) return null;
   if (rule.minAuthority > 0 && authority >= rule.minAuthority) return null;
   if (rule.requireGroupAdmin && session.guildId) {
     const probe = session.onebot || getBotOnebot(session.bot);
-    const role = await getMemberRole(
-      probe,
-      session.bot,
-      session.guildId,
-      session.userId
-    );
+    const role = await getMemberRole(probe, session.bot, session.guildId, session.userId, logger, verbose);
     if (role === "owner" || role === "admin") return null;
   }
   if (rule.requireGroupAdmin && rule.minAuthority > 0) {
-    return `需要群管/群主或 Koishi≥${rule.minAuthority}`;
+    return `需要群管理/群主或至少 ${rule.minAuthority} 级 Koishi 权限`;
   }
-  if (rule.requireGroupAdmin) return "需要群管或群主权限";
-  return `需要 Koishi≥${rule.minAuthority}`;
+  if (rule.requireGroupAdmin) return "需要群管理或群主权限";
+  return `需要至少 ${rule.minAuthority} 级 Koishi 权限`;
 }
 __name(verifyCaller, "verifyCaller");
-function parseTargetId(raw, session) {
-  if (raw) {
-    const segs = import_koishi.segment.parse(raw);
-    const at = segs.find((s) => s.type === "at" && s.attrs?.id);
-    if (at) return String(at.attrs.id);
-    const m = raw.match(/\d{5,}/);
-    if (m) return m[0];
+async function pickManageBot(ctx, guildId, requireOwner, logger, preferBot, verbose, probeOnebot) {
+  const candidates = ctx.bots.filter((b) => b.platform === "onebot");
+  const probeBot = probeOnebot || preferBot && preferBot.onebot || candidates.find((b) => b.onebot) || candidates.find((b) => b.internal?.onebot);
+  const probeInstance = probeBot?.onebot || probeBot?.internal?.onebot || probeOnebot;
+  if (!probeInstance) {
+    logger.warn(`no probe bot with onebot instance for guild=${guildId}`);
+    return null;
   }
-  return session.quote?.user?.id || null;
-}
-__name(parseTargetId, "parseTargetId");
-async function pickManageBot(ctx, guildId, requireOwner, preferBot) {
-  const bots = ctx.bots.filter((b) => b.platform === "onebot");
-  const probe = getBotOnebot(preferBot || bots[0]);
-  if (!probe) return null;
-  for (const bot of bots) {
-    const role = await getMemberRole(probe, bot, guildId, bot.selfId);
-    if (requireOwner ? role === "owner" : role === "owner" || role === "admin") {
-      return { bot, probe };
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  if (preferBot && preferBot.platform === "onebot") {
+    ordered.push(preferBot);
+    seen.add(botKey(preferBot));
+  }
+  for (const bot of candidates) {
+    const k = botKey(bot);
+    if (seen.has(k)) continue;
+    ordered.push(bot);
+    seen.add(k);
+  }
+  const roles = await Promise.all(
+    ordered.map(async (bot) => {
+      const role = await getMemberRole(probeInstance, bot, guildId, bot.selfId, logger, verbose);
+      return { bot, role };
+    })
+  );
+  for (const { bot, role } of roles) {
+    if (!role) continue;
+    const ok = requireOwner ? role === "owner" : role === "owner" || role === "admin";
+    if (ok) {
+      logger[verbose ? "info" : "debug"](`picked bot=${botKey(bot)} role=${role} guild=${guildId}`);
+      return { bot, role, probeOnebot: probeInstance };
     }
   }
+  logger.warn(`no available bot with manage permission in guild=${guildId}`);
   return null;
 }
 __name(pickManageBot, "pickManageBot");
+function parseTargetId(raw, session) {
+  if (raw) {
+    const segments = import_koishi.segment.parse(raw);
+    const at = segments.find((seg) => seg.type === "at" && seg.attrs?.id);
+    const atId = at?.attrs?.id;
+    if (atId) return String(atId);
+    const match = raw.match(/\d{5,}/);
+    if (match) return match[0];
+  }
+  if (session.quote?.user?.id) return String(session.quote.user.id);
+  return null;
+}
+__name(parseTargetId, "parseTargetId");
+function formatRule(rule) {
+  const needAdmin = rule.requireGroupAdmin;
+  const needAuth = rule.minAuthority > 0;
+  if (needAdmin && needAuth) return `群管/群主 或 Koishi≥${rule.minAuthority}`;
+  if (needAdmin) return "群管/群主";
+  if (needAuth) return `Koishi≥${rule.minAuthority}`;
+  return "无限制";
+}
+__name(formatRule, "formatRule");
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+__name(randomInt, "randomInt");
 function apply(ctx, config) {
-  ctx.command("group.manage", "OneBot 群管理").channelFields(["platform"]);
-  ctx.command("group.manage/mute <target:string> <duration:number>", "禁言").alias("gmute").action(async ({ session }, target, duration) => {
-    if (!session?.guildId) return "仅限群聊";
-    const deny = await verifyCaller(session, config.mute);
-    if (deny) return deny;
-    const uid = parseTargetId(target, session);
-    if (!uid || duration <= 0) return "参数错误";
-    const picked = await pickManageBot(ctx, session.guildId, false, session.bot);
-    if (!picked) return "无可用群管 Bot";
-    const role = await getMemberRole(picked.probe, picked.bot, session.guildId, uid);
-    if (role === "owner") return "不能禁言群主";
-    await picked.probe.setGroupBan(Number(session.guildId), Number(uid), duration);
-    roleCache.clear();
-    return `已禁言 ${uid} ${duration} 秒`;
+  const logger = ctx.logger(name);
+  const verbose = config.debug?.verbose ?? false;
+  ctx.command("group.manage", "OneBot 群管", { authority: 0 }).channelFields(["platform"]);
+  ctx.command("group.manage/check <target:string>", "调试：查询 get_group_member_info").alias("gcheck").action(async ({ session }, target) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const userId = parseTargetId(target, session);
+    if (!userId) return "请提供要查询的用户（@ 或 QQ 号）";
+    try {
+      const start = Date.now();
+      const probe = session.onebot || getBotOnebot(session.bot);
+      const info = await callOneBotApi(
+        session.bot,
+        "get_group_member_info",
+        {
+          group_id: Number(session.guildId),
+          user_id: Number(userId),
+          no_cache: false
+        },
+        probe
+      );
+      const cost = Date.now() - start;
+      const role = info?.role ?? "unknown";
+      return `查询成功，用时 ${cost}ms，role=${role}，raw=${JSON.stringify(info)}`;
+    } catch (error) {
+      return `查询失败: ${error?.message || String(error)}`;
+    }
   });
-  ctx.command("group.manage/unmute <target:string>", "解禁").alias("gunmute").action(async ({ session }, target) => {
-    if (!session?.guildId) return "仅限群聊";
-    const deny = await verifyCaller(session, config.unmute);
-    if (deny) return deny;
-    const uid = parseTargetId(target, session);
-    if (!uid) return "参数错误";
-    const picked = await pickManageBot(ctx, session.guildId, false, session.bot);
-    if (!picked) return "无可用群管 Bot";
-    await picked.probe.setGroupBan(Number(session.guildId), Number(uid), 0);
-    roleCache.clear();
-    return `已解禁 ${uid}`;
+  ctx.command("group.manage/status", "查看本群 Bot 权限状态").alias("gstatus").action(async ({ session }) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const probe = session.onebot || getBotOnebot(session.bot);
+    if (!probe) return "当前 Bot 无 onebot 实例，无法查询";
+    const bots = ctx.bots.filter((b) => b.platform === "onebot");
+    const lines = [];
+    for (const b of bots) {
+      const role = await getMemberRole(probe, b, session.guildId, b.selfId, logger, verbose);
+      lines.push(`${b.selfId}: ${role ?? "unknown"}`);
+    }
+    lines.push(`配置：mute=${formatRule(config.mute)} / unmute=${formatRule(config.unmute)} / kick=${formatRule(config.kick)} / title=${formatRule(config.title)}`);
+    lines.push(`自助：gmute.me 随机范围 ${config.selfMute.minSeconds}~${config.selfMute.maxSeconds} 秒`);
+    return lines.join("\n");
   });
-  ctx.command("group.manage/kick <target:string>", "踢人").alias("gkick").action(async ({ session }, target) => {
-    if (!session?.guildId) return "仅限群聊";
-    const deny = await verifyCaller(session, config.kick);
-    if (deny) return deny;
-    const uid = parseTargetId(target, session);
-    if (!uid) return "参数错误";
-    const picked = await pickManageBot(ctx, session.guildId, false, session.bot);
-    if (!picked) return "无可用群管 Bot";
-    const role = await getMemberRole(picked.probe, picked.bot, session.guildId, uid);
-    if (role === "owner") return "不能踢群主";
-    await picked.probe.setGroupKick(Number(session.guildId), Number(uid), false);
-    roleCache.clear();
-    return `已踢出 ${uid}`;
+  ctx.command("group.manage/mute <target:string> <duration:number>", "禁言目标（秒，必须指定）").alias("gmute").action(async ({ session }, target, duration) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const msg = await verifyCaller(session, config.mute, logger, verbose);
+    if (msg) return msg;
+    const userId = parseTargetId(target, session);
+    if (!userId) return "请提供要禁言的用户（@ 或 QQ 号）";
+    const seconds = Number(duration);
+    if (!Number.isFinite(seconds) || seconds <= 0) return "禁言时长必须为大于 0 的整数（秒）";
+    verbose && logger.info(`mute: guild=${session.guildId} caller=${session.userId} bot=${botKey(session.bot)} target=${userId} seconds=${seconds}`);
+    const picked = await pickManageBot(ctx, session.guildId, false, logger, session.bot, verbose, session.onebot);
+    if (!picked) return "没有可用且有群管权限的 Bot";
+    const targetRole = await getMemberRole(picked.probeOnebot, picked.bot, session.guildId, userId, logger, verbose);
+    if (targetRole === "owner") return "无法对群主执行该操作";
+    const actionOnebot = getBotOnebot(picked.bot);
+    if (!actionOnebot) return "选中的 Bot 缺少 onebot 实例，无法执行";
+    try {
+      verbose && logger.info(`mute: use bot=${botKey(picked.bot)} role=${picked.role} duration=${seconds}`);
+      if (typeof actionOnebot.setGroupBan === "function") {
+        await actionOnebot.setGroupBan(Number(session.guildId), Number(userId), Number(seconds));
+      } else {
+        await callOneBotApi(picked.bot, "set_group_ban", {
+          group_id: Number(session.guildId),
+          user_id: Number(userId),
+          duration: Number(seconds)
+        });
+      }
+      roleCache.clear();
+      return `已使用 ${picked.bot.selfId} 禁言 ${userId} ${seconds} 秒`;
+    } catch (error) {
+      logger.warn(error);
+      return "禁言失败，检查 Bot 权限或参数";
+    }
   });
-  ctx.command("group.manage/title <target:string> <title:text>", "设置头衔").alias("gtitle").action(async ({ session }, target, title) => {
-    if (!session?.guildId) return "仅限群聊";
-    const deny = await verifyCaller(session, config.title);
-    if (deny) return deny;
-    const uid = parseTargetId(target, session);
-    if (!uid) return "参数错误";
-    const picked = await pickManageBot(ctx, session.guildId, true, session.bot);
-    if (!picked) return "无群主 Bot";
-    await picked.probe.setGroupSpecialTitle(
-      Number(session.guildId),
-      Number(uid),
-      title.trim(),
-      -1
-    );
-    roleCache.clear();
-    return `已设置头衔`;
+  ctx.command("group.manage/unmute <target:string>", "解除禁言").alias("gunmute").action(async ({ session }, target) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const msg = await verifyCaller(session, config.unmute, logger, verbose);
+    if (msg) return msg;
+    const userId = parseTargetId(target, session);
+    if (!userId) return "请提供要解禁的用户（@ 或 QQ 号）";
+    verbose && logger.info(`unmute: guild=${session.guildId} caller=${session.userId} bot=${botKey(session.bot)} target=${userId}`);
+    const picked = await pickManageBot(ctx, session.guildId, false, logger, session.bot, verbose, session.onebot);
+    if (!picked) return "没有可用且有群管权限的 Bot";
+    const targetRole = await getMemberRole(picked.probeOnebot, picked.bot, session.guildId, userId, logger, verbose);
+    if (targetRole === "owner") return "无法对群主执行该操作";
+    const actionOnebot = getBotOnebot(picked.bot);
+    if (!actionOnebot) return "选中的 Bot 缺少 onebot 实例，无法执行";
+    try {
+      verbose && logger.info(`unmute: use bot=${botKey(picked.bot)} role=${picked.role}`);
+      if (typeof actionOnebot.setGroupBan === "function") {
+        await actionOnebot.setGroupBan(Number(session.guildId), Number(userId), 0);
+      } else {
+        await callOneBotApi(picked.bot, "set_group_ban", {
+          group_id: Number(session.guildId),
+          user_id: Number(userId),
+          duration: 0
+        });
+      }
+      roleCache.clear();
+      return `已使用 ${picked.bot.selfId} 解除 ${userId} 的禁言`;
+    } catch (error) {
+      logger.warn(error);
+      return "解禁失败，检查 Bot 权限或参数";
+    }
+  });
+  ctx.command("group.manage/kick <target:string> [reject:boolean]", "踢出成员").alias("gkick").option("reject", "-r 设为 true 拒绝再次申请").action(async ({ session, options }, target, rejectFlag) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const msg = await verifyCaller(session, config.kick, logger, verbose);
+    if (msg) return msg;
+    const userId = parseTargetId(target, session);
+    if (!userId) return "请提供要踢出的用户（@ 或 QQ 号）";
+    const reject = Boolean(options?.reject ?? rejectFlag);
+    verbose && logger.info(`kick: guild=${session.guildId} caller=${session.userId} bot=${botKey(session.bot)} target=${userId} reject=${reject}`);
+    const picked = await pickManageBot(ctx, session.guildId, false, logger, session.bot, verbose, session.onebot);
+    if (!picked) return "没有可用且有群管权限的 Bot";
+    const targetRole = await getMemberRole(picked.probeOnebot, picked.bot, session.guildId, userId, logger, verbose);
+    if (targetRole === "owner") return "无法对群主执行该操作";
+    const actionOnebot = getBotOnebot(picked.bot);
+    if (!actionOnebot) return "选中的 Bot 缺少 onebot 实例，无法执行";
+    try {
+      verbose && logger.info(`kick: use bot=${botKey(picked.bot)} role=${picked.role}`);
+      if (typeof actionOnebot.setGroupKick === "function") {
+        await actionOnebot.setGroupKick(Number(session.guildId), Number(userId), reject);
+      } else {
+        await callOneBotApi(picked.bot, "set_group_kick", {
+          group_id: Number(session.guildId),
+          user_id: Number(userId),
+          reject_add_request: reject
+        });
+      }
+      roleCache.clear();
+      return `已使用 ${picked.bot.selfId} 踢出 ${userId}${reject ? "（已拒绝再次申请）" : ""}`;
+    } catch (error) {
+      logger.warn(error);
+      return "踢人失败，检查 Bot 权限或参数";
+    }
   });
-  ctx.command("group.manage/mute.me", "禁言我").alias("gmute.me").action(async ({ session }) => {
-    if (!session?.guildId) return "仅限群聊";
-    const deny = await verifyCaller(session, config.mute);
-    if (deny) return deny;
-    const { minSeconds, maxSeconds } = config.selfMute;
+  ctx.command("group.manage/title <target:string> <title:text>", "设置群头衔（需群主 Bot）").alias("gtitle").action(async ({ session }, target, title) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const msg = await verifyCaller(session, config.title, logger, verbose);
+    if (msg) return msg;
+    if (!title?.trim()) return "请提供要设置的头衔";
+    const userId = parseTargetId(target, session);
+    if (!userId) return "请提供要设置头衔的用户（@ 或 QQ 号）";
+    verbose && logger.info(`title: guild=${session.guildId} caller=${session.userId} bot=${botKey(session.bot)} target=${userId} title=${title.trim()}`);
+    const picked = await pickManageBot(ctx, session.guildId, true, logger, session.bot, verbose, session.onebot);
+    if (!picked) return "没有具备群主权限的 Bot 可用";
+    const actionOnebot = getBotOnebot(picked.bot);
+    if (!actionOnebot) return "选中的 Bot 缺少 onebot 实例，无法执行";
+    try {
+      verbose && logger.info(`title: use bot=${botKey(picked.bot)} role=${picked.role}`);
+      if (typeof actionOnebot.setGroupSpecialTitle === "function") {
+        await actionOnebot.setGroupSpecialTitle(Number(session.guildId), Number(userId), title.trim(), -1);
+      } else {
+        await callOneBotApi(picked.bot, "set_group_special_title", {
+          group_id: Number(session.guildId),
+          user_id: Number(userId),
+          special_title: title.trim(),
+          duration: -1
+        });
+      }
+      roleCache.clear();
+      return `已使用 ${picked.bot.selfId} 为 ${userId} 设置头衔：${title.trim()}`;
+    } catch (error) {
+      logger.warn(error);
+      return "设置头衔失败，检查 Bot 权限或参数";
+    }
+  });
+  ctx.command("group.manage/mute.me", "禁言我（随机时长）").alias("gmute.me").action(async ({ session }) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const msg = await verifyCaller(session, config.mute, logger, verbose);
+    if (msg) return msg;
+    const minS = Math.max(1, Math.floor(Number(config.selfMute?.minSeconds ?? 60)));
+    const maxS = Math.max(1, Math.floor(Number(config.selfMute?.maxSeconds ?? 600)));
+    const minSeconds = Math.min(minS, maxS);
+    const maxSeconds = Math.max(minS, maxS);
     const seconds = randomInt(minSeconds, maxSeconds);
-    const picked = await pickManageBot(ctx, session.guildId, false, session.bot);
-    if (!picked) return "无可用群管 Bot";
-    await picked.probe.setGroupBan(
-      Number(session.guildId),
-      Number(session.userId),
-      seconds
-    );
-    roleCache.clear();
-    return `你被禁言 ${seconds} 秒`;
+    verbose && logger.info(`mute.me: guild=${session.guildId} caller=${session.userId} seconds=${seconds}`);
+    const picked = await pickManageBot(ctx, session.guildId, false, logger, session.bot, verbose, session.onebot);
+    if (!picked) return "没有可用且有群管权限的 Bot";
+    const myRole = await getMemberRole(picked.probeOnebot, picked.bot, session.guildId, session.userId, logger, verbose);
+    if (myRole === "owner") return "群主不能禁言自己";
+    const actionOnebot = getBotOnebot(picked.bot);
+    if (!actionOnebot) return "选中的 Bot 缺少 onebot 实例，无法执行";
+    try {
+      if (typeof actionOnebot.setGroupBan === "function") {
+        await actionOnebot.setGroupBan(Number(session.guildId), Number(session.userId), Number(seconds));
+      } else {
+        await callOneBotApi(picked.bot, "set_group_ban", {
+          group_id: Number(session.guildId),
+          user_id: Number(session.userId),
+          duration: Number(seconds)
+        });
+      }
+      roleCache.clear();
+      return `你已被禁言 ${seconds} 秒`;
+    } catch (error) {
+      logger.warn(error);
+      return "禁言失败，检查 Bot 权限或参数";
+    }
   });
-  ctx.command("group.manage/title.apply <title:text>", "申请群头衔").alias("gtitle.apply").action(async ({ session }, title) => {
-    if (!session?.guildId) return "仅限群聊";
-    const deny = await verifyCaller(session, config.title);
-    if (deny) return deny;
-    const picked = await pickManageBot(ctx, session.guildId, true, session.bot);
-    if (!picked) return "无群主 Bot";
-    await picked.probe.setGroupSpecialTitle(
-      Number(session.guildId),
-      Number(session.userId),
-      title.trim(),
-      -1
-    );
-    roleCache.clear();
-    return `你的头衔已设置为：${title}`;
+  ctx.command("group.manage/title.apply <title:text>", "申请群头衔（给自己）").alias("gtitle.apply").action(async ({ session }, title) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const t = title?.trim();
+    if (!t) return "请提供要申请的头衔";
+    const msg = await verifyCaller(session, config.title, logger, verbose);
+    if (msg) return msg;
+    verbose && logger.info(`title.apply: guild=${session.guildId} caller=${session.userId} title=${t}`);
+    const picked = await pickManageBot(ctx, session.guildId, true, logger, session.bot, verbose, session.onebot);
+    if (!picked) return "没有具备群主权限的 Bot 可用";
+    const actionOnebot = getBotOnebot(picked.bot);
+    if (!actionOnebot) return "选中的 Bot 缺少 onebot 实例，无法执行";
+    try {
+      if (typeof actionOnebot.setGroupSpecialTitle === "function") {
+        await actionOnebot.setGroupSpecialTitle(Number(session.guildId), Number(session.userId), t, -1);
+      } else {
+        await callOneBotApi(picked.bot, "set_group_special_title", {
+          group_id: Number(session.guildId),
+          user_id: Number(session.userId),
+          special_title: t,
+          duration: -1
+        });
+      }
+      roleCache.clear();
+      return `已为你设置头衔：${t}`;
+    } catch (error) {
+      logger.warn(error);
+      return "设置头衔失败，检查 Bot 权限或参数";
+    }
   });
 }
 __name(apply, "apply");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-onebot-group-manage",
   "description": "主要针对多bot环境的群管插件，自动使用有权限的bot",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [