koishi-plugin-onebot-group-manage 0.0.2

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+import { Context, Schema } from 'koishi';
+export declare const name = "onebot-group-manage";
+interface ActionRule {
+    requireGroupAdmin: boolean;
+    minAuthority: number;
+}
+interface DebugOptions {
+    verbose: boolean;
+}
+interface SelfMuteConfig {
+    minSeconds: number;
+    maxSeconds: number;
+}
+export interface Config {
+    mute: ActionRule;
+    unmute: ActionRule;
+    kick: ActionRule;
+    title: ActionRule;
+    selfMute: SelfMuteConfig;
+    debug?: DebugOptions;
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;
+export {};

package/lib/index.js

@@ -0,0 +1,224 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+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 表示不校验")
+});
+var Config = import_koishi.Schema.object({
+  mute: actionSchema.description("禁言配置"),
+  unmute: actionSchema.description("解禁配置"),
+  kick: 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("禁言我配置"),
+  debug: import_koishi.Schema.object({
+    verbose: import_koishi.Schema.boolean().default(false)
+  }).default({ verbose: false })
+});
+function withTimeout(p, ms) {
+  return Promise.race([
+    p,
+    new Promise((_, r) => setTimeout(() => r(new Error(`timeout ${ms}ms`)), ms))
+  ]);
+}
+__name(withTimeout, "withTimeout");
+function getBotOnebot(bot) {
+  return bot?.onebot || bot?.internal?.onebot || bot?.internal || null;
+}
+__name(getBotOnebot, "getBotOnebot");
+function randomInt(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+__name(randomInt, "randomInt");
+async function getMemberRole(probe, bot, guildId, userId, logger, verbose) {
+  const key = `${bot.selfId}:${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 role = info?.role ?? null;
+    if (role) roleCache.set(key, { role, expire: Date.now() + ROLE_CACHE_TTL });
+    return role;
+  } catch {
+    return null;
+  }
+}
+__name(getMemberRole, "getMemberRole");
+async function verifyCaller(session, rule) {
+  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
+    );
+    if (role === "owner" || role === "admin") return null;
+  }
+  if (rule.requireGroupAdmin && rule.minAuthority > 0) {
+    return `需要群管/群主或 Koishi≥${rule.minAuthority}`;
+  }
+  if (rule.requireGroupAdmin) return "需要群管或群主权限";
+  return `需要 Koishi≥${rule.minAuthority}`;
+}
+__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];
+  }
+  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 };
+    }
+  }
+  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);
+    roleCache.clear();
+    return `已禁言 ${uid} ${duration} 秒`;
+  });
+  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/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/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/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;
+    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} 秒`;
+  });
+  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}`;
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  name
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "koishi-plugin-onebot-group-manage",
+  "description": "主要针对多bot环境的群管插件，自动使用有权限的bot",
+  "version": "0.0.2",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.7"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-onebot-group-manage
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-onebot-group-manage?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-onebot-group-manage)
+
+主要针对多bot环境的群管插件，自动使用有权限的bot