mioku-plugin-admin 2.2.3 → 2.3.1

package/notify/welcome.ts

@@ -73,8 +73,18 @@ async function flushBatch(options: {
   groupId: number;
   groupName: string;
   members: PendingMember[];
+  promptInjections?: { content: string; title?: string }[];
 }): Promise<string> {
-  const { ctx, aiService, config, selfId, groupId, groupName, members } = options;
+  const {
+    ctx,
+    aiService,
+    config,
+    selfId,
+    groupId,
+    groupName,
+    members,
+    promptInjections,
+  } = options;
   if (!members.length) return "";
 
   const names = members.map((m) => m.memberName || String(m.userId));
@@ -104,12 +114,13 @@ async function flushBatch(options: {
       groupId,
       send: true,
       instruction: [
-        `当前有 ${members.length} 位新成员同时入群，请一次性发送一段统一的欢迎语（不要逐个 @ 欢迎、不要重复点名）。`,
+        `当前有 ${members.length} 位新成员同时入群，请一次性发送一段统一的欢迎语（不要逐个 @ 欢迎、不要重复点名）不要长篇大论，精简即可。`,
         `新成员昵称：${userList}`,
         `新成员 QQ：${userIdList}`,
         `所在群：${groupName}`,
         `${config.welcome.aiPrompt || ""}`,
       ].join("\n"),
+      promptInjections,
     });
 
     return "";
@@ -119,87 +130,134 @@ async function flushBatch(options: {
   }
 }
 
+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;
-
-    if (!cfg.welcome.enabled) return;
+  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);
+      const groupName =
+        String(event?.group?.group_name || "").trim() || String(groupId);
 
-    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}`);
+      if (
+        shouldSuppress &&
+        (await shouldSuppress({ selfId, groupId, userId, groupName }))
+      ) {
+        return;
       }
-      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;
-    }
+      if (!cfg.welcome.enabled) return;
 
-    const memberName = await resolveMemberName(ctx, groupId, userId, selfId);
-    if (!state.members.some((m) => m.userId === userId)) {
-      state.members.push({ userId, memberName });
-    }
+      const batchWindowMs = Math.max(0, Number(cfg.welcome.batchWindowMs) || 0);
 
-    if (state.timer) {
-      return;
-    }
-
-    state.timer = setTimeout(async () => {
-      try {
-        const pending = state;
-        batches.delete(key);
-        if (!pending || !pending.members.length) return;
-
-        const currentConfig = getConfig();
+      if (batchWindowMs === 0) {
+        const memberName = await resolveMemberName(
+          ctx,
+          groupId,
+          userId,
+          selfId,
+        );
         const welcomeMessage = await flushBatch({
           ctx,
           aiService,
-          config: currentConfig,
+          config: cfg,
           selfId,
           groupId,
-          groupName: pending.groupName,
-          members: pending.members,
+          groupName,
+          members: [{ userId, memberName }],
         });
         if (!welcomeMessage) return;
-
         const bot = ctx.pickBot(selfId);
         if (!bot) return;
         try {
@@ -207,11 +265,59 @@ export function registerWelcomeHandler(
         } catch (error) {
           ctx.logger.warn(`发送入群欢迎失败: ${error}`);
         }
-      } catch (error) {
-        ctx.logger.error(`admin welcome 批次处理失败: ${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 });
       }
-    }, batchWindowMs);
-  });
+
+      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()) {
@@ -220,4 +326,4 @@ export function registerWelcomeHandler(
     batches.clear();
     dispose();
   };
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mioku-plugin-admin",
-  "version": "2.2.3",
+  "version": "2.3.1",
   "description": "管理插件，提供事件通知与群管/个人管理指令",
   "main": "index.ts",
   "type": "module",
@@ -117,6 +117,26 @@
         "id": "welcome",
         "event": "notice.group.increase",
         "description": "新人入群相关功能"
+      },
+      {
+        "id": "/开启验证",
+        "match": "/^[/#]开启验证$/"
+      },
+      {
+        "id": "/关闭验证",
+        "match": "/^[/#]关闭验证$/"
+      },
+      {
+        "id": "/切换验证模式",
+        "match": "/^[/#]切换验证模式/"
+      },
+      {
+        "id": "/绕过验证",
+        "match": "/^[/#]绕过验证/"
+      },
+      {
+        "id": "/重新验证",
+        "match": "/^[/#]重新验证/"
       }
     ],
     "help": {
@@ -240,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,101 @@
+import type { MiokiContext } from "mioki";
+import {
+  resolveVerifyPrompt,
+  type VerifyConfig,
+  type VerifyGroupConfig,
+} 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,
+  groupCfg: VerifyGroupConfig,
+  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 basePrompt = cfg.chiralPrompt.replace(
+      "{count}",
+      String(captcha.regions.length),
+    );
+    const prompt = resolveVerifyPrompt(basePrompt, groupCfg);
+    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,169 @@
+export type VerifyMode = "reaction" | "number" | "chiral";
+
+export const MAX_EXTRA_PROMPT_LENGTH = 50;
+
+export interface VerifyGroupConfig {
+  groupId: number;
+  enabled: boolean;
+  mode: VerifyMode;
+  extraPrompt: string;
+}
+
+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 normalizeExtraPrompt(value: unknown): string {
+  if (typeof value !== "string") return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  return Array.from(trimmed).slice(0, MAX_EXTRA_PROMPT_LENGTH).join("");
+}
+
+export function resolveVerifyPrompt(
+  basePrompt: string,
+  groupCfg: VerifyGroupConfig | undefined,
+): string {
+  const extra = String(groupCfg?.extraPrompt || "").trim();
+  if (!extra) return basePrompt;
+  return `${basePrompt}\n${extra}`;
+}
+
+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),
+    extraPrompt: normalizeExtraPrompt(raw?.extraPrompt ?? raw?.extra_prompt),
+  };
+}
+
+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", extraPrompt: "" };
+}
+
+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 };
+  const normalizedPatch: Partial<Omit<VerifyGroupConfig, "groupId">> = {
+    ...patch,
+  };
+  if (patch.extraPrompt !== undefined) {
+    normalizedPatch.extraPrompt = normalizeExtraPrompt(patch.extraPrompt);
+  }
+  if (idx >= 0) {
+    next.groups = config.groups.map((g, i) =>
+      i === idx ? { ...g, ...normalizedPatch } : g,
+    );
+  } else {
+    next.groups = [
+      ...config.groups,
+      {
+        groupId,
+        enabled: false,
+        mode: "reaction",
+        extraPrompt: "",
+        ...normalizedPatch,
+      },
+    ];
+  }
+  return next;
+}