mioku-plugin-admin 2.2.2 → 2.3.0

package/notify/welcome.ts

@@ -0,0 +1,313 @@
+import { type MiokiContext, wait } from "mioki";
+import { getPluginRuntimeState, type AIService } from "mioku";
+import type { AdminConfig } from "../config";
+
+export async function resolveMemberName(
+  ctx: MiokiContext,
+  groupId: number,
+  userId: number,
+  selfId: number,
+): Promise<string> {
+  try {
+    const member = await ctx
+      .pickBot(selfId)
+      .getGroupMemberInfo(groupId, userId);
+    return (
+      String(member?.card || "").trim() ||
+      String(member?.nickname || "").trim() ||
+      String(userId)
+    );
+  } catch {
+    return String(userId);
+  }
+}
+
+interface PendingMember {
+  userId: number;
+  memberName: string;
+}
+
+interface BatchState {
+  members: PendingMember[];
+  timer: ReturnType<typeof setTimeout> | null;
+  groupName: string;
+}
+
+const RUNTIME_KEY = "welcomeBatch";
+
+function getBatchMap(): Map<string, BatchState> {
+  const state = getPluginRuntimeState("admin");
+  if (!state[RUNTIME_KEY]) {
+    state[RUNTIME_KEY] = new Map<string, BatchState>();
+  }
+  return state[RUNTIME_KEY] as Map<string, BatchState>;
+}
+
+function batchKey(selfId: number, groupId: number): string {
+  return `${selfId}:${groupId}`;
+}
+
+function renderTemplate(
+  template: string,
+  values: Record<string, string>,
+): string {
+  let output = String(template || "");
+  for (const [key, value] of Object.entries(values)) {
+    output = output.split(`{${key}}`).join(value);
+  }
+  return output;
+}
+
+function normalizeGeneratedText(value: string): string {
+  return String(value || "")
+    .replace(/[`"'“”‘’]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+async function flushBatch(options: {
+  ctx: MiokiContext;
+  aiService?: AIService;
+  config: AdminConfig;
+  selfId: number;
+  groupId: number;
+  groupName: string;
+  members: PendingMember[];
+  promptInjections?: { content: string; title?: string }[];
+}): Promise<string> {
+  const { ctx, aiService, config, selfId, groupId, groupName, members, promptInjections } =
+    options;
+  if (!members.length) return "";
+
+  const names = members.map((m) => m.memberName || String(m.userId));
+  const userList = names.join("、");
+  const userIdList = members.map((m) => String(m.userId)).join(", ");
+
+  const fallbackText =
+    normalizeGeneratedText(
+      renderTemplate(config.welcome.text, {
+        user: userList,
+        group: groupName,
+      }),
+    ) || `欢迎新人～`;
+
+  if (config.welcome.mode !== "ai") {
+    return fallbackText;
+  }
+
+  const chatRuntime = aiService?.getChatRuntime();
+  if (!chatRuntime) {
+    return fallbackText;
+  }
+
+  try {
+    await chatRuntime.generateNotice({
+      selfId,
+      groupId,
+      send: true,
+      instruction: [
+        `当前有 ${members.length} 位新成员同时入群，请一次性发送一段统一的欢迎语（不要逐个 @ 欢迎、不要重复点名）。`,
+        `新成员昵称：${userList}`,
+        `新成员 QQ：${userIdList}`,
+        `所在群：${groupName}`,
+        `${config.welcome.aiPrompt || ""}`,
+      ].join("\n"),
+      promptInjections,
+    });
+
+    return "";
+  } catch (error) {
+    ctx.logger.error(`admin welcome chat-runtime 生成失败: ${error}`);
+    return fallbackText;
+  }
+}
+
+async function sendSingleWelcome(options: {
+  ctx: MiokiContext;
+  aiService?: AIService;
+  config: AdminConfig;
+  selfId: number;
+  groupId: number;
+  groupName: string;
+  userId: number;
+  memberName: string;
+  promptInjections?: { content: string; title?: string }[];
+}): Promise<void> {
+  const {
+    ctx,
+    aiService,
+    config,
+    selfId,
+    groupId,
+    groupName,
+    userId,
+    memberName,
+    promptInjections,
+  } = options;
+  const welcomeMessage = await flushBatch({
+    ctx,
+    aiService,
+    config,
+    selfId,
+    groupId,
+    groupName,
+    members: [{ userId, memberName }],
+    promptInjections,
+  });
+  if (!welcomeMessage) return;
+  const bot = ctx.pickBot(selfId);
+  if (!bot) return;
+  try {
+    await bot.sendGroupMsg(groupId, [ctx.segment.text(welcomeMessage)]);
+  } catch (error) {
+    ctx.logger.warn(`发送入群欢迎失败: ${error}`);
+  }
+}
+
+export async function triggerSingleWelcome(options: {
+  ctx: MiokiContext;
+  aiService?: AIService;
+  getConfig: () => AdminConfig;
+  selfId: number;
+  groupId: number;
+  groupName: string;
+  userId: number;
+  memberName?: string;
+  promptInjections?: { content: string; title?: string }[];
+}): Promise<void> {
+  const memberName =
+    options.memberName ||
+    (await resolveMemberName(
+      options.ctx,
+      options.groupId,
+      options.userId,
+      options.selfId,
+    ));
+  await sendSingleWelcome({
+    ctx: options.ctx,
+    aiService: options.aiService,
+    config: options.getConfig(),
+    selfId: options.selfId,
+    groupId: options.groupId,
+    groupName: options.groupName,
+    userId: options.userId,
+    memberName,
+    promptInjections: options.promptInjections,
+  });
+}
+
+export function registerWelcomeHandler(
+  ctx: MiokiContext,
+  aiService: AIService | undefined,
+  getConfig: () => AdminConfig,
+  shouldSuppress?: (info: {
+    selfId: number;
+    groupId: number;
+    userId: number;
+    groupName: string;
+  }) => Promise<boolean> | boolean,
+): () => void {
+  const batches = getBatchMap();
+
+  const dispose = ctx.handle("notice.group.increase" as any, async (event: any) => {
+    const cfg = getConfig();
+    const selfId = Number(event?.self_id || ctx.self_id);
+    const groupId = Number(event?.group_id || 0);
+    const userId = Number(event?.user_id || 0);
+    if (!groupId || !userId) return;
+    if (userId === selfId) return;
+
+    const groupName =
+      String(event?.group?.group_name || "").trim() || String(groupId);
+
+    if (
+      shouldSuppress &&
+      (await shouldSuppress({ selfId, groupId, userId, groupName }))
+    ) {
+      return;
+    }
+
+    if (!cfg.welcome.enabled) return;
+
+    const batchWindowMs = Math.max(0, Number(cfg.welcome.batchWindowMs) || 0);
+
+    if (batchWindowMs === 0) {
+      const memberName = await resolveMemberName(ctx, groupId, userId, selfId);
+      const welcomeMessage = await flushBatch({
+        ctx,
+        aiService,
+        config: cfg,
+        selfId,
+        groupId,
+        groupName,
+        members: [{ userId, memberName }],
+      });
+      if (!welcomeMessage) return;
+      const bot = ctx.pickBot(selfId);
+      if (!bot) return;
+      try {
+        await bot.sendGroupMsg(groupId, [ctx.segment.text(welcomeMessage)]);
+      } catch (error) {
+        ctx.logger.warn(`发送入群欢迎失败: ${error}`);
+      }
+      return;
+    }
+
+    const key = batchKey(selfId, groupId);
+    let state = batches.get(key);
+    if (!state) {
+      state = { members: [], timer: null, groupName };
+      batches.set(key, state);
+    }
+    if (groupName && groupName !== String(groupId)) {
+      state.groupName = groupName;
+    }
+
+    const memberName = await resolveMemberName(ctx, groupId, userId, selfId);
+    if (!state.members.some((m) => m.userId === userId)) {
+      state.members.push({ userId, memberName });
+    }
+
+    if (state.timer) {
+      return;
+    }
+
+    state.timer = setTimeout(async () => {
+      try {
+        const pending = state;
+        batches.delete(key);
+        if (!pending || !pending.members.length) return;
+
+        const currentConfig = getConfig();
+        const welcomeMessage = await flushBatch({
+          ctx,
+          aiService,
+          config: currentConfig,
+          selfId,
+          groupId,
+          groupName: pending.groupName,
+          members: pending.members,
+        });
+        if (!welcomeMessage) return;
+
+        const bot = ctx.pickBot(selfId);
+        if (!bot) return;
+        try {
+          await bot.sendGroupMsg(groupId, [ctx.segment.text(welcomeMessage)]);
+        } catch (error) {
+          ctx.logger.warn(`发送入群欢迎失败: ${error}`);
+        }
+      } catch (error) {
+        ctx.logger.error(`admin welcome 批次处理失败: ${error}`);
+      }
+    }, batchWindowMs);
+  });
+
+  return () => {
+    for (const state of batches.values()) {
+      if (state.timer) clearTimeout(state.timer);
+    }
+    batches.clear();
+    dispose();
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-admin",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "管理插件，提供事件通知与群管/个人管理指令",
   "main": "index.ts",
   "type": "module",
@@ -112,6 +112,31 @@
       {
         "id": "/全部群聊",
         "match": "/^\\/全部群聊/"
+      },
+      {
+        "id": "welcome",
+        "event": "notice.group.increase",
+        "description": "新人入群相关功能"
+      },
+      {
+        "id": "/开启验证",
+        "match": "/^[/#]开启验证$/"
+      },
+      {
+        "id": "/关闭验证",
+        "match": "/^[/#]关闭验证$/"
+      },
+      {
+        "id": "/切换验证模式",
+        "match": "/^[/#]切换验证模式/"
+      },
+      {
+        "id": "/绕过验证",
+        "match": "/^[/#]绕过验证/"
+      },
+      {
+        "id": "/重新验证",
+        "match": "/^[/#]重新验证/"
       }
     ],
     "help": {
@@ -235,6 +260,34 @@
           "cmd": "/全部群聊",
           "desc": "获取全部群聊列表",
           "role": "master"
+        },
+        {
+          "cmd": "/开启验证",
+          "desc": "开启本群入群验证",
+          "role": "admin"
+        },
+        {
+          "cmd": "/关闭验证",
+          "desc": "关闭本群入群验证",
+          "role": "admin"
+        },
+        {
+          "cmd": "/切换验证模式",
+          "desc": "切换验证模式：回应/数字/手性碳",
+          "usage": "/切换验证模式 回应",
+          "role": "admin"
+        },
+        {
+          "cmd": "/绕过验证",
+          "desc": "绕过指定新成员的验证直接欢迎",
+          "usage": "/绕过验证 @新成员",
+          "role": "admin"
+        },
+        {
+          "cmd": "/重新验证",
+          "desc": "让指定成员重新进行入群验证",
+          "usage": "/重新验证 @成员",
+          "role": "admin"
         }
       ]
     }

package/verify/chiral.ts

@@ -0,0 +1,95 @@
+import type { MiokiContext } from "mioki";
+import type { VerifyConfig } from "./config";
+import type { PendingVerify } from "./types";
+
+interface ChiralCaptcha {
+  regions: string[];
+  imageDataUrl: string;
+}
+
+function extractRegions(text: string): string[] {
+  const matches = String(text || "").match(/[A-Za-z]\s*\d+/g);
+  if (!matches) return [];
+  return matches.map((m) => m.replace(/\s+/g, "").toUpperCase());
+}
+
+async function fetchChiralCaptcha(
+  apiUrl: string,
+  difficulty: "simple" | "hard",
+): Promise<ChiralCaptcha> {
+  const res = await fetch(
+    `${apiUrl}/captcha/chiralCarbon/getChiralCarbonCaptcha`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ answer: true, hint: difficulty === "simple" }),
+    },
+  );
+  if (!res.ok) {
+    throw new Error(`手性碳验证接口返回 ${res.status}`);
+  }
+  const json: any = await res.json();
+  const data = json?.data?.data;
+  const regions: string[] = Array.isArray(data?.regions)
+    ? data.regions.map((r: any) => String(r).toUpperCase())
+    : [];
+  const imageDataUrl = String(data?.base64 || "").trim();
+  if (!regions.length || !imageDataUrl) {
+    throw new Error("手性碳验证接口返回数据缺失");
+  }
+  return { regions, imageDataUrl };
+}
+
+export async function prepareChiral(
+  ctx: MiokiContext,
+  cfg: VerifyConfig,
+  p: PendingVerify,
+): Promise<boolean> {
+  const bot = ctx.pickBot(p.selfId);
+  if (!bot) return false;
+  try {
+    const captcha = await fetchChiralCaptcha(cfg.chiralApiUrl, cfg.chiralDifficulty);
+    p.requiredRegions = captcha.regions;
+    p.matchedRegions = new Set<string>();
+    const prompt = cfg.chiralPrompt.replace(
+      "{count}",
+      String(captcha.regions.length),
+    );
+    await bot.sendGroupMsg(p.groupId, [
+      ctx.segment.at(String(p.userId)),
+      ctx.segment.text(` ${prompt}`),
+      ctx.segment.image(captcha.imageDataUrl),
+    ]);
+    return true;
+  } catch (err) {
+    ctx.logger.error(`admin verify 手性碳验证准备失败: ${err}`);
+    return false;
+  }
+}
+
+export type ChiralCheckResult = {
+  status: "pass" | "progress" | "none";
+  remaining: number;
+};
+
+export function checkChiralAnswer(
+  p: PendingVerify,
+  text: string,
+): ChiralCheckResult {
+  const required = p.requiredRegions ?? [];
+  if (!required.length) return { status: "none", remaining: 0 };
+  if (!p.matchedRegions) p.matchedRegions = new Set<string>();
+
+  const requiredSet = new Set(required);
+  let progressed = false;
+  for (const region of extractRegions(text)) {
+    if (requiredSet.has(region) && !p.matchedRegions.has(region)) {
+      p.matchedRegions.add(region);
+      progressed = true;
+    }
+  }
+
+  const remaining = requiredSet.size - p.matchedRegions.size;
+  if (remaining <= 0) return { status: "pass", remaining: 0 };
+  return { status: progressed ? "progress" : "none", remaining };
+}

package/verify/config.ts

@@ -0,0 +1,137 @@
+export type VerifyMode = "reaction" | "number" | "chiral";
+
+export interface VerifyGroupConfig {
+  groupId: number;
+  enabled: boolean;
+  mode: VerifyMode;
+}
+
+export interface VerifyConfig {
+  groups: VerifyGroupConfig[];
+  reactionEmojiId: string;
+  reactionDelayMs: number;
+  verifyTimeoutMs: number;
+  reactionPrompt: string;
+  numberPrompt: string;
+  chiralApiUrl: string;
+  chiralDifficulty: "simple" | "hard";
+  chiralPrompt: string;
+  maxInvalidMessages: number;
+  kickOnFail: boolean;
+  kickOnTimeout: boolean;
+}
+
+export const DEFAULT_VERIFY_CONFIG: VerifyConfig = {
+  groups: [],
+  reactionEmojiId: "424",
+  reactionDelayMs: 3000,
+  verifyTimeoutMs: 120000,
+  reactionPrompt:
+    "新来的小伙伴请在2分钟内点击下方红色按钮完成验证 不听话会被移出群聊喵~",
+  numberPrompt:
+    "新来的小伙伴请在2分钟内回答下面的题目完成验证，不听话移出群聊喵~\n请问：{question}",
+  chiralApiUrl: "https://carbon.crystelf.top",
+  chiralDifficulty: "simple",
+  chiralPrompt:
+    "新来的小伙伴请在2分钟内完成下面的手性碳验证：找出图中{count}个手性碳所在的格子，回复格子编号即可，不听话会被移出群聊喵~",
+  maxInvalidMessages: 5,
+  kickOnFail: true,
+  kickOnTimeout: true,
+};
+
+export function normalizeVerifyMode(value: unknown): VerifyMode {
+  const v = String(value || "").trim();
+  if (v === "number" || v === "数字") return "number";
+  if (v === "chiral" || v === "手性碳") return "chiral";
+  return "reaction";
+}
+
+function normalizeVerifyGroup(raw: any): VerifyGroupConfig {
+  const groupId = Number(raw?.groupId || raw?.group_id || 0);
+  return {
+    groupId: groupId > 0 ? groupId : 0,
+    enabled: raw?.enabled === true,
+    mode: normalizeVerifyMode(raw?.mode),
+  };
+}
+
+export function normalizeVerifyConfig(raw: any): VerifyConfig {
+  const groups: VerifyGroupConfig[] = Array.isArray(raw?.groups)
+    ? raw.groups
+        .map((g: any) => normalizeVerifyGroup(g))
+        .filter((g: VerifyGroupConfig) => g.groupId > 0)
+    : [];
+
+  const numOr = (value: unknown, fallback: number): number => {
+    const num = Number(value);
+    return Number.isFinite(num) && num >= 0 ? Math.floor(num) : fallback;
+  };
+
+  return {
+    groups,
+    reactionEmojiId:
+      typeof raw?.reactionEmojiId === "string" && raw.reactionEmojiId.trim()
+        ? raw.reactionEmojiId.trim()
+        : DEFAULT_VERIFY_CONFIG.reactionEmojiId,
+    reactionDelayMs: numOr(
+      raw?.reactionDelayMs,
+      DEFAULT_VERIFY_CONFIG.reactionDelayMs,
+    ),
+    verifyTimeoutMs: numOr(
+      raw?.verifyTimeoutMs,
+      DEFAULT_VERIFY_CONFIG.verifyTimeoutMs,
+    ),
+    reactionPrompt:
+      typeof raw?.reactionPrompt === "string" && raw.reactionPrompt.trim()
+        ? raw.reactionPrompt
+        : DEFAULT_VERIFY_CONFIG.reactionPrompt,
+    numberPrompt:
+      typeof raw?.numberPrompt === "string" && raw.numberPrompt.trim()
+        ? raw.numberPrompt
+        : DEFAULT_VERIFY_CONFIG.numberPrompt,
+    chiralApiUrl:
+      typeof raw?.chiralApiUrl === "string" && raw.chiralApiUrl.trim()
+        ? raw.chiralApiUrl.trim().replace(/\/+$/, "")
+        : DEFAULT_VERIFY_CONFIG.chiralApiUrl,
+    chiralDifficulty: raw?.chiralDifficulty === "hard" ? "hard" : "simple",
+    chiralPrompt:
+      typeof raw?.chiralPrompt === "string" && raw.chiralPrompt.trim()
+        ? raw.chiralPrompt
+        : DEFAULT_VERIFY_CONFIG.chiralPrompt,
+    maxInvalidMessages: numOr(
+      raw?.maxInvalidMessages,
+      DEFAULT_VERIFY_CONFIG.maxInvalidMessages,
+    ),
+    kickOnFail: raw?.kickOnFail ?? DEFAULT_VERIFY_CONFIG.kickOnFail,
+    kickOnTimeout: raw?.kickOnTimeout ?? DEFAULT_VERIFY_CONFIG.kickOnTimeout,
+  };
+}
+
+export function getGroupVerifyConfig(
+  config: VerifyConfig,
+  groupId: number,
+): VerifyGroupConfig {
+  const found = config.groups.find((g) => g.groupId === groupId);
+  if (found) return found;
+  return { groupId, enabled: false, mode: "reaction" };
+}
+
+export function upsertGroupVerifyConfig(
+  config: VerifyConfig,
+  groupId: number,
+  patch: Partial<Omit<VerifyGroupConfig, "groupId">>,
+): VerifyConfig {
+  const idx = config.groups.findIndex((g) => g.groupId === groupId);
+  const next = { ...config };
+  if (idx >= 0) {
+    next.groups = config.groups.map((g, i) =>
+      i === idx ? { ...g, ...patch } : g,
+    );
+  } else {
+    next.groups = [
+      ...config.groups,
+      { groupId, enabled: false, mode: "reaction", ...patch },
+    ];
+  }
+  return next;
+}