mioku-plugin-admin 2.2.3 → 2.3.0

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;
+}

package/verify/index.ts

@@ -0,0 +1,359 @@
+import type { MiokiContext } from "mioki";
+import { getMemberRole } from "../config";
+import { resolveMemberName, triggerSingleWelcome } from "../notify/welcome";
+import { getGroupVerifyConfig, upsertGroupVerifyConfig } from "./config";
+import type {
+  MemberJoinInfo,
+  PendingVerify,
+  VerifyController,
+  VerifyControllerOptions,
+} from "./types";
+import { clearTimers, getPendingMap, pendingKey } from "./state";
+import { isReactionPass, sendReactionPrompt } from "./reaction";
+import { isNumberAnswerCorrect, sendNumberPrompt } from "./number";
+import { checkChiralAnswer, prepareChiral } from "./chiral";
+
+const PASS_REACTION_EMOJI_ID = "144";
+
+const VERIFY_PASS_PROMPT_INJECTION = {
+  title: "新成员通过入群验证",
+  content: "这位新成员刚刚通过了入群验证，请在欢迎语中点到验证通过类似话语",
+};
+
+export function createVerifyController(
+  options: VerifyControllerOptions,
+): VerifyController {
+  const {
+    ctx,
+    aiService,
+    getConfig,
+    getVerifyConfig,
+    getWelcomeEnabled,
+    setVerifyConfig,
+  } = options;
+  const pending = getPendingMap();
+
+  async function disableGroupVerify(groupId: number, reason: string) {
+    ctx.logger.warn(`admin verify 关闭群 ${groupId} 验证：${reason}`);
+    try {
+      await setVerifyConfig(
+        upsertGroupVerifyConfig(getVerifyConfig(), groupId, { enabled: false }),
+      );
+    } catch (err) {
+      ctx.logger.error(`admin verify 关闭群验证写回配置失败: ${err}`);
+    }
+  }
+
+  async function recallMessage(bot: any, messageId: number) {
+    try {
+      await bot.api("delete_msg", { message_id: messageId });
+    } catch (err) {
+      ctx.logger.warn(`admin verify 撤回消息失败: ${err}`);
+    }
+  }
+
+  async function kickMember(bot: any, groupId: number, userId: number) {
+    try {
+      await bot.api("set_group_kick", {
+        group_id: groupId,
+        user_id: userId,
+        reject_add_request: false,
+      });
+    } catch (err) {
+      ctx.logger.warn(`admin verify 踢出成员失败: ${err}`);
+    }
+  }
+
+  function removePending(key: string) {
+    const p = pending.get(key);
+    if (p) {
+      clearTimers(p);
+      pending.delete(key);
+    }
+  }
+
+  async function passVerification(p: PendingVerify) {
+    if (p.passed) return;
+    p.passed = true;
+    clearTimers(p);
+    pending.delete(pendingKey(p.selfId, p.groupId, p.userId));
+
+    if (p.mode === "reaction" && p.promptMessageId) {
+      const bot = ctx.pickBot(p.selfId);
+      if (bot) {
+        try {
+          await bot.addReaction(p.promptMessageId, PASS_REACTION_EMOJI_ID);
+        } catch (err) {
+          ctx.logger.warn(`admin verify 通过表态失败: ${err}`);
+        }
+      }
+    }
+
+    if (!getWelcomeEnabled()) return;
+    try {
+      await triggerSingleWelcome({
+        ctx,
+        aiService,
+        getConfig,
+        selfId: p.selfId,
+        groupId: p.groupId,
+        groupName: p.groupName,
+        userId: p.userId,
+        memberName: p.memberName,
+        promptInjections: [VERIFY_PASS_PROMPT_INJECTION],
+      });
+    } catch (err) {
+      ctx.logger.error(`admin verify 通过后欢迎失败: ${err}`);
+    }
+  }
+
+  async function failKick(p: PendingVerify, reason: string) {
+    clearTimers(p);
+    pending.delete(pendingKey(p.selfId, p.groupId, p.userId));
+    const cfg = getVerifyConfig();
+    if (!cfg.kickOnFail) return;
+    const bot = ctx.pickBot(p.selfId);
+    if (!bot) return;
+    ctx.logger.info(
+      `admin verify 踢出群 ${p.groupId} 用户 ${p.userId}（${reason}）`,
+    );
+    await kickMember(bot, p.groupId, p.userId);
+  }
+
+  async function timeoutExpire(p: PendingVerify) {
+    p.timeoutTimer = null;
+    const cfg = getVerifyConfig();
+    if (!cfg.kickOnTimeout) {
+      pending.delete(pendingKey(p.selfId, p.groupId, p.userId));
+      return;
+    }
+    const bot = ctx.pickBot(p.selfId);
+    if (!bot) {
+      pending.delete(pendingKey(p.selfId, p.groupId, p.userId));
+      return;
+    }
+    try {
+      await bot.sendGroupMsg(p.groupId, [
+        ctx.segment.at(String(p.userId)),
+        ctx.segment.text(" 验证超时啦，下次再来哦～"),
+      ]);
+    } catch (err) {
+      ctx.logger.warn(`admin verify 超时提示发送失败: ${err}`);
+    }
+    ctx.logger.info(`admin verify 超时踢出群 ${p.groupId} 用户 ${p.userId}`);
+    await kickMember(bot, p.groupId, p.userId);
+    pending.delete(pendingKey(p.selfId, p.groupId, p.userId));
+  }
+
+  async function startVerification(
+    info: MemberJoinInfo,
+    skipDelay = false,
+  ): Promise<boolean> {
+    const cfg = getVerifyConfig();
+    const groupCfg = getGroupVerifyConfig(cfg, info.groupId);
+    if (!groupCfg.enabled) return false;
+
+    const bot = ctx.pickBot(info.selfId);
+    if (!bot) return false;
+
+    const botRole = await getMemberRole(bot, info.groupId, info.selfId);
+    if (botRole !== "owner" && botRole !== "admin") {
+      try {
+        await bot.sendGroupMsg(info.groupId, [
+          ctx.segment.text("我在不是管理员，没法入群验证啦，本群验证已关闭~"),
+        ]);
+      } catch (err) {
+        ctx.logger.warn(`admin verify 提醒本群验证关闭失败: ${err}`);
+      }
+      await disableGroupVerify(
+        info.groupId,
+        `Bot 群内身份为 ${botRole}，非群主/管理员`,
+      );
+      return false;
+    }
+
+    const mode = groupCfg.mode;
+    const memberName = await resolveMemberName(
+      ctx,
+      info.groupId,
+      info.userId,
+      info.selfId,
+    );
+
+    const entry: PendingVerify = {
+      selfId: info.selfId,
+      groupId: info.groupId,
+      userId: info.userId,
+      memberName,
+      groupName: info.groupName,
+      mode,
+      invalidCount: 0,
+      startedAt: Date.now(),
+      passed: false,
+      timeoutTimer: null,
+      delayTimer: null,
+    };
+    if (mode === "reaction") {
+      entry.reactionEmojiId = cfg.reactionEmojiId;
+    }
+
+    const key = pendingKey(info.selfId, info.groupId, info.userId);
+    pending.set(key, entry);
+
+    if (mode === "reaction") {
+      const delay = skipDelay ? 0 : Math.max(0, cfg.reactionDelayMs);
+      entry.delayTimer = setTimeout(() => {
+        entry.delayTimer = null;
+        void sendReactionPrompt(ctx, cfg, entry);
+      }, delay);
+    } else if (mode === "number") {
+      void sendNumberPrompt(ctx, cfg, entry);
+    } else if (mode === "chiral") {
+      const ok = await prepareChiral(ctx, cfg, entry);
+      if (!ok) {
+        // 验证服务不可用时放行，避免误伤
+        removePending(key);
+        return false;
+      }
+    }
+
+    entry.timeoutTimer = setTimeout(
+      () => {
+        void timeoutExpire(entry);
+      },
+      Math.max(1000, cfg.verifyTimeoutMs),
+    );
+
+    return true;
+  }
+
+  async function onGroupMessage(event: any) {
+    if (event?.message_type !== "group") return;
+    const selfId = Number(event?.self_id || 0);
+    const groupId = Number(event?.group_id || 0);
+    const userId = Number(event?.user_id || 0);
+    if (!selfId || !groupId || !userId) return;
+    if (userId === selfId) return;
+
+    const key = pendingKey(selfId, groupId, userId);
+    const p = pending.get(key);
+    if (!p || p.passed) return;
+
+    const cfg = getVerifyConfig();
+    const text = ctx.text(event) || "";
+    const messageId = Number(event?.message_id || 0);
+    const bot = ctx.pickBot(selfId);
+
+    if (p.mode === "number" && isNumberAnswerCorrect(p, text)) {
+      await passVerification(p);
+      return;
+    }
+
+    if (p.mode === "chiral") {
+      const result = checkChiralAnswer(p, text);
+      if (result.status === "pass") {
+        await passVerification(p);
+        return;
+      }
+      if (result.status === "progress") {
+        if (bot) {
+          try {
+            await bot.sendGroupMsg(groupId, [
+              ctx.segment.at(String(userId)),
+              ctx.segment.text(` 答对一部分啦，还差 ${result.remaining} 个哦~`),
+            ]);
+          } catch (err) {
+            ctx.logger.warn(`admin verify 手性碳进度提示发送失败: ${err}`);
+          }
+        }
+        return;
+      }
+    }
+
+    if (messageId && bot) {
+      await recallMessage(bot, messageId);
+    }
+
+    p.invalidCount += 1;
+    if (p.invalidCount >= cfg.maxInvalidMessages) {
+      await failKick(p, `连续 ${cfg.maxInvalidMessages} 次无关消息`);
+    }
+  }
+
+  async function onGroupReaction(event: any) {
+    const selfId = Number(event?.self_id || 0);
+    const groupId = Number(event?.group_id || 0);
+    const userId = Number(event?.user_id || 0);
+    if (!selfId || !groupId || !userId) return;
+    if (userId === selfId) return;
+    if (event?.is_add === false) return;
+
+    const key = pendingKey(selfId, groupId, userId);
+    const p = pending.get(key);
+    if (!p || p.passed || p.mode !== "reaction") return;
+
+    if (isReactionPass(p, event)) {
+      await passVerification(p);
+    }
+  }
+
+  const messageDispose = ctx.handle(
+    "message.group" as any,
+    async (event: any) => {
+      try {
+        await onGroupMessage(event);
+      } catch (err) {
+        ctx.logger.error(`admin verify message 处理失败: ${err}`);
+      }
+    },
+  );
+
+  const reactionDispose = ctx.handle(
+    "notice.group.reaction" as any,
+    async (event: any) => {
+      try {
+        await onGroupReaction(event);
+      } catch (err) {
+        ctx.logger.error(`admin verify reaction 处理失败: ${err}`);
+      }
+    },
+  );
+
+  const decreaseDispose = ctx.handle(
+    "notice.group.decrease" as any,
+    async (event: any) => {
+      const selfId = Number(event?.self_id || 0);
+      const groupId = Number(event?.group_id || 0);
+      const userId = Number(event?.user_id || 0);
+      if (!selfId || !groupId || !userId) return;
+      const key = pendingKey(selfId, groupId, userId);
+      if (!pending.has(key)) return;
+      removePending(key);
+      ctx.logger.info(
+        `admin verify 成员 ${userId} 退出群 ${groupId}，清除验证队列`,
+      );
+    },
+  );
+
+  async function restartVerification(info: MemberJoinInfo): Promise<boolean> {
+    removePending(pendingKey(info.selfId, info.groupId, info.userId));
+    return startVerification(info, true);
+  }
+
+  async function bypassVerification(info: MemberJoinInfo): Promise<void> {
+    removePending(pendingKey(info.selfId, info.groupId, info.userId));
+  }
+
+  return {
+    handleMemberJoin: startVerification,
+    restartVerification,
+    bypassVerification,
+    dispose() {
+      for (const p of pending.values()) clearTimers(p);
+      pending.clear();
+      messageDispose();
+      reactionDispose();
+      decreaseDispose();
+    },
+  };
+}

package/verify/number.ts

@@ -0,0 +1,42 @@
+import type { MiokiContext } from "mioki";
+import type { VerifyConfig } from "./config";
+import type { PendingVerify } from "./types";
+
+function genNumberQuestion(): { question: string; answer: number } {
+  const a = Math.floor(Math.random() * 99) + 1;
+  const b = Math.floor(Math.random() * 99) + 1;
+  if (Math.random() < 0.5 && a >= b) {
+    return { question: `${a} - ${b} = ?`, answer: a - b };
+  }
+  return { question: `${a} + ${b} = ?`, answer: a + b };
+}
+
+function extractNumbers(text: string): number[] {
+  const matches = String(text || "").match(/-?\d+/g);
+  return matches ? matches.map(Number) : [];
+}
+
+export async function sendNumberPrompt(
+  ctx: MiokiContext,
+  cfg: VerifyConfig,
+  p: PendingVerify,
+): Promise<void> {
+  const bot = ctx.pickBot(p.selfId);
+  if (!bot) return;
+  const { question, answer } = genNumberQuestion();
+  p.numberAnswer = answer;
+  const prompt = cfg.numberPrompt.replace("{question}", question);
+  try {
+    await bot.sendGroupMsg(p.groupId, [
+      ctx.segment.at(String(p.userId)),
+      ctx.segment.text(` ${prompt}`),
+    ]);
+  } catch (err) {
+    ctx.logger.warn(`admin verify 发送数字提示失败: ${err}`);
+  }
+}
+
+export function isNumberAnswerCorrect(p: PendingVerify, text: string): boolean {
+  if (p.numberAnswer == null) return false;
+  return extractNumbers(text).includes(p.numberAnswer);
+}

package/verify/reaction.ts

@@ -0,0 +1,38 @@
+import type { MiokiContext } from "mioki";
+import type { VerifyConfig } from "./config";
+import type { PendingVerify } from "./types";
+
+export async function sendReactionPrompt(
+  ctx: MiokiContext,
+  cfg: VerifyConfig,
+  p: PendingVerify,
+): Promise<void> {
+  const bot = ctx.pickBot(p.selfId);
+  if (!bot) return;
+  let messageId: number | undefined;
+  try {
+    const res = await bot.sendGroupMsg(p.groupId, [
+      ctx.segment.at(String(p.userId)),
+      ctx.segment.text(` ${cfg.reactionPrompt}`),
+    ]);
+    messageId = Number(res?.message_id || 0) || undefined;
+  } catch (err) {
+    ctx.logger.warn(`admin verify 发送回应提示失败: ${err}`);
+    return;
+  }
+  if (!messageId) return;
+  p.promptMessageId = messageId;
+  try {
+    await bot.addReaction(messageId, cfg.reactionEmojiId);
+  } catch (err) {
+    ctx.logger.warn(`admin verify 添加表态失败: ${err}`);
+  }
+}
+
+export function isReactionPass(p: PendingVerify, event: any): boolean {
+  if (!p.promptMessageId) return false;
+  if (Number(event?.message_id || 0) !== p.promptMessageId) return false;
+  const emojiId = String(p.reactionEmojiId || "");
+  const likes: any[] = Array.isArray(event?.likes) ? event.likes : [];
+  return likes.some((l) => String(l?.emoji_id || "") === emojiId);
+}

package/verify/state.ts

@@ -0,0 +1,31 @@
+import { getPluginRuntimeState } from "mioku";
+import type { PendingVerify } from "./types";
+
+const RUNTIME_KEY = "verifyPending";
+
+export function getPendingMap(): Map<string, PendingVerify> {
+  const state = getPluginRuntimeState("admin");
+  if (!state[RUNTIME_KEY]) {
+    state[RUNTIME_KEY] = new Map<string, PendingVerify>();
+  }
+  return state[RUNTIME_KEY] as Map<string, PendingVerify>;
+}
+
+export function pendingKey(
+  selfId: number,
+  groupId: number,
+  userId: number,
+): string {
+  return `${selfId}:${groupId}:${userId}`;
+}
+
+export function clearTimers(p: PendingVerify) {
+  if (p.timeoutTimer) {
+    clearTimeout(p.timeoutTimer);
+    p.timeoutTimer = null;
+  }
+  if (p.delayTimer) {
+    clearTimeout(p.delayTimer);
+    p.delayTimer = null;
+  }
+}