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

package/lib/index.d.ts

@@ -17,6 +17,7 @@ export interface Config {
     kick: ActionRule;
     title: ActionRule;
     selfMute: SelfMuteConfig;
+    chatlunaTools?: boolean;
     debug?: DebugOptions;
 }
 export declare const Config: Schema<Config>;

package/lib/index.js

@@ -26,193 +26,553 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
+
+// src/tools.ts
+var import_tools = require("@langchain/core/tools");
+var import_zod = require("zod");
+var GroupMuteTool = class extends import_tools.StructuredTool {
+  constructor(runMute, verbose) {
+    super();
+    this.runMute = runMute;
+    this.verbose = verbose;
+  }
+  static {
+    __name(this, "GroupMuteTool");
+  }
+  name = "group_mute";
+  description = "在群内禁言成员";
+  schema = import_zod.z.object({
+    groupId: import_zod.z.string().trim().min(1).describe("目标群号，不填则使用当前会话群").optional(),
+    userId: import_zod.z.string().trim().min(1).describe("要禁言的成员 QQ 号"),
+    duration: import_zod.z.number().int().positive().describe("禁言时长（秒），0秒为解除禁言")
+  });
+  async _call(input, _runManager, runnableConfig) {
+    const session = runnableConfig?.configurable?.session;
+    if (!session) return "缺少 session，无法执行禁言";
+    const result = await this.runMute(session, {
+      targetId: input.userId,
+      duration: input.duration,
+      guildId: input.groupId
+    });
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+};
+var GroupTitleTool = class extends import_tools.StructuredTool {
+  constructor(runTitle, verbose) {
+    super();
+    this.runTitle = runTitle;
+    this.verbose = verbose;
+  }
+  static {
+    __name(this, "GroupTitleTool");
+  }
+  name = "group_set_title";
+  description = "为成员设置群头衔（需群主权限）";
+  schema = import_zod.z.object({
+    groupId: import_zod.z.string().trim().min(1).describe("目标群号，不填则使用当前会话群").optional(),
+    userId: import_zod.z.string().trim().min(1).describe("要设置头衔的成员 QQ 号"),
+    title: import_zod.z.string().trim().min(1).describe("头衔文案")
+  });
+  async _call(input, _runManager, runnableConfig) {
+    const session = runnableConfig?.configurable?.session;
+    if (!session) return "缺少 session，无法设置头衔";
+    const result = await this.runTitle(session, {
+      targetId: input.userId,
+      title: input.title,
+      guildId: input.groupId
+    });
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+};
+function registerChatlunaTools(ctx, config, logger, verbose, handlers) {
+  const platform = ctx.chatluna?.platform;
+  if (!platform) {
+    logger.debug("chatluna 未安装，跳过群管工具注册");
+    return;
+  }
+  ctx.effect(
+    () => platform.registerTool("group_mute", {
+      createTool: /* @__PURE__ */ __name(() => new GroupMuteTool(
+        (session, params) => handlers.performMute(ctx, session, params, config, logger, verbose),
+        verbose
+      ), "createTool"),
+      selector: /* @__PURE__ */ __name(() => true, "selector")
+    })
+  );
+  ctx.effect(
+    () => platform.registerTool("group_set_title", {
+      createTool: /* @__PURE__ */ __name(() => new GroupTitleTool(
+        (session, params) => handlers.performTitle(ctx, session, params, config, logger, verbose),
+        verbose
+      ), "createTool"),
+      selector: /* @__PURE__ */ __name(() => true, "selector")
+    })
+  );
+}
+__name(registerChatlunaTools, "registerChatlunaTools");
+
+// src/index.ts
 var name = "onebot-group-manage";
 var ROLE_CACHE_TTL = 3e4;
 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("自助禁言配置"),
+  chatlunaTools: import_koishi.Schema.boolean().default(true).description("启用 ChatLuna 工具注册（需安装 chatluna）"),
   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, guildIdOverride) {
   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 guildId = guildIdOverride ?? session.guildId;
+  if (rule.requireGroupAdmin && !guildId) return "仅限群聊使用";
+  if (rule.requireGroupAdmin && 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, 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");
+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;
+  }
+  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 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];
+    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];
   }
-  return session.quote?.user?.id || null;
+  if (session.quote?.user?.id) return String(session.quote.user.id);
+  return 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 };
+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");
+async function performMute(ctx, session, params, config, logger, verbose) {
+  const guildId = params.guildId ?? session.guildId;
+  if (!guildId) return "仅限群聊使用";
+  const targetId = params.targetId ?? parseTargetId(params.targetRaw || "", session);
+  if (!targetId) return "请提供要禁言的用户（@ 或 QQ 号）";
+  const seconds = Number(params.duration);
+  if (!Number.isFinite(seconds) || seconds <= 0) return "禁言时长必须为大于 0 的整数（秒）";
+  const msg = await verifyCaller(session, config.mute, logger, verbose, guildId);
+  if (msg) return msg;
+  verbose && logger.info(
+    `mute: guild=${guildId} caller=${session.userId} bot=${botKey(session.bot)} target=${targetId} seconds=${seconds}`
+  );
+  const picked = await pickManageBot(ctx, guildId, false, logger, session.bot, verbose, session.onebot);
+  if (!picked) return "没有可用且有群管权限的 Bot";
+  const targetRole = await getMemberRole(picked.probeOnebot, picked.bot, guildId, targetId, 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(guildId), Number(targetId), Number(seconds));
+    } else {
+      await callOneBotApi(picked.bot, "set_group_ban", {
+        group_id: Number(guildId),
+        user_id: Number(targetId),
+        duration: Number(seconds)
+      });
     }
+    roleCache.clear();
+    return `已使用 ${picked.bot.selfId} 禁言 ${targetId} ${seconds} 秒`;
+  } catch (error) {
+    logger.warn(error);
+    return "禁言失败，检查 Bot 权限或参数";
   }
-  return null;
 }
-__name(pickManageBot, "pickManageBot");
-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);
+__name(performMute, "performMute");
+async function performTitle(ctx, session, params, config, logger, verbose) {
+  const guildId = params.guildId ?? session.guildId;
+  if (!guildId) return "仅限群聊使用";
+  const title = params.title?.trim();
+  if (!title) return "请提供要设置的头衔";
+  const userId = params.targetId ?? parseTargetId(params.targetRaw || "", session);
+  if (!userId) return "请提供要设置头衔的用户（@ 或 QQ 号）";
+  const msg = await verifyCaller(session, config.title, logger, verbose, guildId);
+  if (msg) return msg;
+  verbose && logger.info(
+    `title: guild=${guildId} caller=${session.userId} bot=${botKey(session.bot)} target=${userId} title=${title}`
+  );
+  const picked = await pickManageBot(ctx, 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(guildId), Number(userId), title, -1);
+    } else {
+      await callOneBotApi(picked.bot, "set_group_special_title", {
+        group_id: Number(guildId),
+        user_id: Number(userId),
+        special_title: title,
+        duration: -1
+      });
+    }
     roleCache.clear();
-    return `已禁言 ${uid} ${duration} 秒`;
+    return `已使用 ${picked.bot.selfId} 为 ${userId} 设置头衔：${title}`;
+  } catch (error) {
+    logger.warn(error);
+    return "设置头衔失败，检查 Bot 权限或参数";
+  }
+}
+__name(performTitle, "performTitle");
+function apply(ctx, config) {
+  const logger = ctx.logger(name);
+  const verbose = config.debug?.verbose ?? false;
+  if (config.chatlunaTools) {
+    registerChatlunaTools(ctx, config, logger, verbose, {
+      performMute,
+      performTitle
+    });
+  }
+  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) return "缺少 session";
+    return performMute(
+      ctx,
+      session,
+      { targetRaw: target, duration: Number(duration) },
+      config,
+      logger,
+      verbose
+    );
   });
-  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
+  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/title <target:string> <title:text>", "设置群头衔（需群主 Bot）").alias("gtitle").action(async ({ session }, target, title) => {
+    if (!session) return "缺少 session";
+    return performTitle(
+      ctx,
+      session,
+      { targetRaw: target, title: title || "", guildId: session.guildId },
+      config,
+      logger,
+      verbose
     );
-    roleCache.clear();
-    return `已设置头衔`;
   });
-  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/mute.me", "禁言我（随机时长）").alias("gmute.me").action(async ({ session }) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    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
+    const result = await performMute(
+      ctx,
+      session,
+      { targetId: session.userId, duration: seconds, guildId: session.guildId },
+      config,
+      logger,
+      verbose
     );
-    roleCache.clear();
-    return `你被禁言 ${seconds} 秒`;
+    if (typeof result === "string" && result.startsWith("已使用")) return `你已被禁言 ${seconds} 秒`;
+    return result;
   });
-  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
+  ctx.command("group.manage/title.apply <title:text>", "申请群头衔（给自己）").alias("gtitle.apply").action(async ({ session }, title) => {
+    if (!session?.guildId) return "仅限群聊使用";
+    const result = await performTitle(
+      ctx,
+      session,
+      { targetId: session.userId, title: title || "", guildId: session.guildId },
+      config,
+      logger,
+      verbose
     );
-    roleCache.clear();
-    return `你的头衔已设置为：${title}`;
+    if (typeof result === "string" && result.startsWith("已使用")) {
+      return `已为你设置头衔：${(title || "").trim()}`;
+    }
+    return result;
   });
 }
 __name(apply, "apply");

package/lib/tools.d.ts

@@ -0,0 +1,17 @@
+import { Context, Session } from 'koishi';
+interface Handlers {
+    performMute: (ctx: Context, session: Session, params: {
+        targetId: string;
+        duration: number;
+        guildId?: string;
+    }, ...rest: any[]) => Promise<string>;
+    performTitle: (ctx: Context, session: Session, params: {
+        targetId: string;
+        title: string;
+        guildId?: string;
+    }, ...rest: any[]) => Promise<string>;
+}
+export declare function registerChatlunaTools(ctx: Context, config: {
+    chatlunaTools?: boolean;
+}, logger: ReturnType<Context['logger']>, verbose: boolean | undefined, handlers: Handlers): void;
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-onebot-group-manage",
   "description": "主要针对多bot环境的群管插件，自动使用有权限的bot",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -15,6 +15,9 @@
     "plugin"
   ],
   "peerDependencies": {
-    "koishi": "^4.18.7"
+    "koishi": "^4.18.7",
+    "@langchain/core": "^0.3.0",
+    "koishi-plugin-chatluna": "^1.3.0",
+    "zod": "^3.23.8"
   }
 }