koishi-plugin-onebot-group-manage 0.0.3 → 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,6 +26,92 @@ __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;
@@ -43,6 +129,7 @@ var Config = 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("自助禁言配置"),
+  chatlunaTools: import_koishi.Schema.boolean().default(true).description("启用 ChatLuna 工具注册（需安装 chatluna）"),
   debug: import_koishi.Schema.object({
     verbose: import_koishi.Schema.boolean().default(false).description("开启详细日志（仅建议排查问题时启用）")
   }).default({ verbose: false }).description("调试选项")
@@ -166,13 +253,15 @@ async function getMemberRole(probeOnebot, targetBot, guildId, userId, logger, ve
   }
 }
 __name(getMemberRole, "getMemberRole");
-async function verifyCaller(session, rule, logger, verbose) {
+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, logger, verbose);
+    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) {
@@ -246,9 +335,88 @@ 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 权限或参数";
+  }
+}
+__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 `已使用 ${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 "仅限群聊使用";
@@ -289,37 +457,15 @@ function apply(ctx, config) {
     return lines.join("\n");
   });
   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 权限或参数";
-    }
+    if (!session) return "缺少 session";
+    return performMute(
+      ctx,
+      session,
+      { targetRaw: target, duration: Number(duration) },
+      config,
+      logger,
+      verbose
+    );
   });
   ctx.command("group.manage/unmute <target:string>", "解除禁言").alias("gunmute").action(async ({ session }, target) => {
     if (!session?.guildId) return "仅限群聊使用";
@@ -385,97 +531,48 @@ function apply(ctx, config) {
     }
   });
   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 权限或参数";
-    }
+    if (!session) return "缺少 session";
+    return performTitle(
+      ctx,
+      session,
+      { targetRaw: target, title: title || "", guildId: session.guildId },
+      config,
+      logger,
+      verbose
+    );
   });
   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);
-    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 权限或参数";
-    }
+    const result = await performMute(
+      ctx,
+      session,
+      { targetId: session.userId, duration: seconds, guildId: session.guildId },
+      config,
+      logger,
+      verbose
+    );
+    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 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 权限或参数";
+    const result = await performTitle(
+      ctx,
+      session,
+      { targetId: session.userId, title: title || "", guildId: session.guildId },
+      config,
+      logger,
+      verbose
+    );
+    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.3",
+  "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"
   }
 }