koishi-plugin-group-control 1.1.0-alpha.0 → 1.1.0-alpha.2

package/lib/index.js

@@ -0,0 +1,2091 @@
+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 name9 in all)
+    __defProp(target, name9, { get: all[name9], 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: () => apply8,
+  inject: () => inject,
+  name: () => name8
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/database.ts
+var database_exports = {};
+__export(database_exports, {
+  BLACKLIST_PLATFORM: () => BLACKLIST_PLATFORM,
+  addPendingFriendRequest: () => addPendingFriendRequest,
+  addPendingInvite: () => addPendingInvite,
+  addToSmallGroupWhitelist: () => addToSmallGroupWhitelist,
+  apply: () => apply,
+  blacklistKicked: () => blacklistKicked,
+  clearApprovedGuild: () => clearApprovedGuild,
+  clearBlacklistedGuilds: () => clearBlacklistedGuilds,
+  clearExpiredPendingFriendRequests: () => clearExpiredPendingFriendRequests,
+  clearExpiredPendingInvites: () => clearExpiredPendingInvites,
+  clearExpiredSelfLeft: () => clearExpiredSelfLeft,
+  clearSelfLeft: () => clearSelfLeft,
+  consumeSelfLeft: () => consumeSelfLeft,
+  createBlacklistedGuild: () => createBlacklistedGuild,
+  getAllBlacklistedGuilds: () => getAllBlacklistedGuilds,
+  getAllPendingFriendRequests: () => getAllPendingFriendRequests,
+  getAllPendingInvites: () => getAllPendingInvites,
+  getAllSmallGroupWhitelist: () => getAllSmallGroupWhitelist,
+  getBlacklistedGuild: () => getBlacklistedGuild,
+  getCommandFrequencyRecord: () => getCommandFrequencyRecord,
+  getGroupBotStatus: () => getGroupBotStatus,
+  getPendingFriendRequest: () => getPendingFriendRequest,
+  getPendingInvite: () => getPendingInvite,
+  isApprovedGuild: () => isApprovedGuild,
+  isInSmallGroupWhitelist: () => isInSmallGroupWhitelist,
+  markApprovedGuild: () => markApprovedGuild,
+  markSelfLeft: () => markSelfLeft,
+  name: () => name,
+  removeBlacklistedGuild: () => removeBlacklistedGuild,
+  removeFromSmallGroupWhitelist: () => removeFromSmallGroupWhitelist,
+  removePendingFriendRequest: () => removePendingFriendRequest,
+  removePendingInvite: () => removePendingInvite,
+  setGroupBotStatus: () => setGroupBotStatus,
+  updateCommandFrequencyRecord: () => updateCommandFrequencyRecord
+});
+
+// src/utils.ts
+function isBlacklistEnabled(config) {
+  if (!config.enableBlacklist) return "黑名单功能未启用。";
+  return null;
+}
+__name(isBlacklistEnabled, "isBlacklistEnabled");
+function parseGuildId(input) {
+  if (!input) return null;
+  const match = input.trim().match(/^(?:[^:]+:)?(\d+)$/);
+  return match ? match[1] : null;
+}
+__name(parseGuildId, "parseGuildId");
+function toOneBotNumber(input) {
+  const id = parseGuildId(input);
+  if (!id) return null;
+  const value = Number(id);
+  return Number.isSafeInteger(value) ? value : null;
+}
+__name(toOneBotNumber, "toOneBotNumber");
+function getAdminCommandOptions(config) {
+  return config.permission.mode === "koishi" ? { authority: config.permission.koishiAuthority } : {};
+}
+__name(getAdminCommandOptions, "getAdminCommandOptions");
+function formatDate(timestamp) {
+  return new Date(timestamp * 1e3).toLocaleString();
+}
+__name(formatDate, "formatDate");
+async function notifyAdmins(bot, config, message) {
+  if (config.admin.notificationGroupId) {
+    try {
+      await bot.sendMessage(config.admin.notificationGroupId, message);
+      return;
+    } catch (error) {
+      console.error(`发送通知到通知群 ${config.admin.notificationGroupId} 失败:`, error);
+    }
+  }
+  if (config.admin.adminQQs?.length > 0) {
+    for (const adminQQ of config.admin.adminQQs) {
+      try {
+        await bot.sendPrivateMessage(adminQQ, message);
+      } catch (error) {
+        console.error(`发送通知给管理员 ${adminQQ} 失败:`, error);
+      }
+    }
+  }
+}
+__name(notifyAdmins, "notifyAdmins");
+function isGlobalAdmin(session, config) {
+  if (config.permission.mode === "koishi") {
+    const user = session.user;
+    return typeof user?.authority === "number" && user.authority >= config.permission.koishiAuthority;
+  }
+  return config.admin.adminQQs?.includes(session.userId) ?? false;
+}
+__name(isGlobalAdmin, "isGlobalAdmin");
+var GUILD_ADMIN_CACHE_TTL = 30 * 1e3;
+var GUILD_ADMIN_NEGATIVE_CACHE_TTL = 5 * 1e3;
+var GUILD_ADMIN_CACHE_MAX = 1e3;
+var SimpleLRUCache = class {
+  constructor(ttlMs, maxSize = 1e3) {
+    this.ttlMs = ttlMs;
+    this.maxSize = maxSize;
+  }
+  static {
+    __name(this, "SimpleLRUCache");
+  }
+  entries = /* @__PURE__ */ new Map();
+  get(key) {
+    const entry = this.entries.get(key);
+    if (!entry) return void 0;
+    if (entry.expiresAt <= Date.now()) {
+      this.entries.delete(key);
+      return void 0;
+    }
+    this.entries.delete(key);
+    this.entries.set(key, entry);
+    return entry.value;
+  }
+  set(key, value, ttlMs = this.ttlMs) {
+    this.entries.set(key, { value, expiresAt: Date.now() + ttlMs });
+    this.prune();
+  }
+  delete(key) {
+    this.entries.delete(key);
+  }
+  clear() {
+    this.entries.clear();
+  }
+  prune(now = Date.now()) {
+    for (const [key, entry] of this.entries) {
+      if (entry.expiresAt <= now) this.entries.delete(key);
+    }
+    while (this.entries.size > this.maxSize) {
+      const oldestKey = this.entries.keys().next().value;
+      if (!oldestKey) break;
+      this.entries.delete(oldestKey);
+    }
+  }
+};
+var guildAdminCache = new SimpleLRUCache(GUILD_ADMIN_CACHE_TTL, GUILD_ADMIN_CACHE_MAX);
+function guildAdminCacheKey(session) {
+  if (!session.guildId || !session.userId) return null;
+  return `${session.platform}:${session.guildId}:${session.userId}`;
+}
+__name(guildAdminCacheKey, "guildAdminCacheKey");
+function getCachedGuildAdmin(session) {
+  const key = guildAdminCacheKey(session);
+  if (!key) return void 0;
+  return guildAdminCache.get(key);
+}
+__name(getCachedGuildAdmin, "getCachedGuildAdmin");
+function setCachedGuildAdmin(session, value) {
+  const key = guildAdminCacheKey(session);
+  if (!key) return;
+  const ttl = value ? GUILD_ADMIN_CACHE_TTL : GUILD_ADMIN_NEGATIVE_CACHE_TTL;
+  guildAdminCache.set(key, value, ttl);
+}
+__name(setCachedGuildAdmin, "setCachedGuildAdmin");
+function clearGuildAdminCache() {
+  guildAdminCache.clear();
+}
+__name(clearGuildAdminCache, "clearGuildAdminCache");
+function hasAdminRole(member) {
+  if (!member) return false;
+  const data = member.data ?? member.member ?? member.sender ?? member;
+  const role = data.role ?? data.memberRole ?? data.permissions;
+  if (role === "admin" || role === "owner" || role === "administrator") return true;
+  const roles = data.roles ?? data.roleIds;
+  if (Array.isArray(roles)) {
+    return roles.some((role2) => role2 === "admin" || role2 === "owner" || role2 === "administrator");
+  }
+  return false;
+}
+__name(hasAdminRole, "hasAdminRole");
+async function getOneBotGroupMemberInfo(session) {
+  const guildId = Number(parseGuildId(session.guildId) ?? session.guildId);
+  const userId = Number(parseGuildId(session.userId) ?? session.userId);
+  if (!Number.isFinite(guildId) || !Number.isFinite(userId)) return null;
+  return await session.bot.internal?.getGroupMemberInfo?.(guildId, userId, true);
+}
+__name(getOneBotGroupMemberInfo, "getOneBotGroupMemberInfo");
+async function isGuildAdmin(session) {
+  const event = session.event;
+  const raw = event?._data ?? session.original ?? session.onebot;
+  if (hasAdminRole(event?.member) || hasAdminRole(raw?.sender)) {
+    setCachedGuildAdmin(session, true);
+    return true;
+  }
+  const cached = getCachedGuildAdmin(session);
+  if (cached !== void 0) return cached;
+  let result = false;
+  try {
+    const member = await session.bot.getGuildMember(session.guildId, session.userId);
+    if (hasAdminRole(member)) result = true;
+  } catch {
+  }
+  if (!result) {
+    try {
+      const info = await getOneBotGroupMemberInfo(session);
+      if (hasAdminRole(info)) result = true;
+    } catch {
+    }
+  }
+  setCachedGuildAdmin(session, result);
+  return result;
+}
+__name(isGuildAdmin, "isGuildAdmin");
+async function hasGuildPermission(session, config) {
+  if (config.permission.mode === "koishi") {
+    const user = session.user;
+    return typeof user?.authority === "number" && user.authority >= config.permission.koishiAuthority;
+  }
+  if (isGlobalAdmin(session, config)) return true;
+  return await isGuildAdmin(session);
+}
+__name(hasGuildPermission, "hasGuildPermission");
+function hasGlobalPermission(session, config) {
+  return isGlobalAdmin(session, config);
+}
+__name(hasGlobalPermission, "hasGlobalPermission");
+var ADMIN_COMMANDS = /* @__PURE__ */ new Set([
+  "bot-on",
+  "bot-off",
+  "quit",
+  "gc",
+  "gc.banlist",
+  "gc.unban",
+  "gc.ban",
+  "gc.clearban",
+  "gc.approve",
+  "gc.reject",
+  "gc.pending",
+  "gc.sg-add",
+  "gc.sg-rm",
+  "gc.sg-list",
+  "gc.friends",
+  "gc.delfriend",
+  "gc.groups",
+  "gc.leave",
+  "gc.friend-pending",
+  "gc.friend-approve",
+  "gc.friend-reject",
+  "gc.fp",
+  "gc.fa",
+  "gc.fr"
+]);
+
+// src/database.ts
+var name = "group-control-database";
+function apply(ctx) {
+  ctx.on("dispose", () => {
+    groupBotStatusCache.clear();
+  });
+  ctx.model.extend("blacklisted_guild", {
+    platform: "string",
+    guildId: "string",
+    timestamp: "integer",
+    reason: "string"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("command_frequency_record", {
+    platform: "string",
+    guildId: "string",
+    commandCount: "integer",
+    lastCommandTime: "integer",
+    warningSent: "boolean",
+    blockExpiryTime: "integer",
+    firstWarningTime: "integer",
+    blockCount: "integer",
+    lastBlockNotifyTime: "integer"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("group_bot_status", {
+    platform: "string",
+    guildId: "string",
+    botEnabled: "boolean"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("small_group_whitelist", {
+    platform: "string",
+    guildId: "string"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("self_left_guild", {
+    platform: "string",
+    guildId: "string",
+    selfId: "string",
+    timestamp: "integer"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("approved_guild", {
+    platform: "string",
+    guildId: "string",
+    selfId: "string",
+    timestamp: "integer"
+  }, { primary: ["platform", "guildId"] });
+  ctx.model.extend("pending_invite", {
+    platform: "string",
+    groupId: "string",
+    selfId: "string",
+    userId: "string",
+    userName: "string",
+    groupName: "string",
+    time: "integer",
+    flag: "string"
+  }, { primary: ["platform", "groupId"] });
+  ctx.model.extend("pending_friend_request", {
+    platform: "string",
+    selfId: "string",
+    userId: "string",
+    nickname: "string",
+    comment: "string",
+    flag: "string",
+    time: "integer"
+  }, { primary: ["platform", "userId"] });
+}
+__name(apply, "apply");
+var BLACKLIST_PLATFORM = "onebot";
+function normalizeId(id) {
+  return parseGuildId(id) ?? id;
+}
+__name(normalizeId, "normalizeId");
+function scopedId(id, selfId) {
+  return `${normalizeId(selfId)}#${normalizeId(id)}`;
+}
+__name(scopedId, "scopedId");
+function unscopedId(id) {
+  const match = id.match(/^\d+#(.+)$/);
+  return match ? normalizeId(match[1]) : normalizeId(id);
+}
+__name(unscopedId, "unscopedId");
+function isScopedId(id) {
+  return /^\d+#.+$/.test(id);
+}
+__name(isScopedId, "isScopedId");
+function decodePendingInvite(row) {
+  return { ...row, groupId: unscopedId(row.groupId), userId: unscopedId(row.userId) };
+}
+__name(decodePendingInvite, "decodePendingInvite");
+function decodePendingFriendRequest(row) {
+  return { ...row, userId: unscopedId(row.userId) };
+}
+__name(decodePendingFriendRequest, "decodePendingFriendRequest");
+async function getRowsByNormalizedId(ctx, table, field, platform, id) {
+  const normalized = normalizeId(id);
+  const rows = await ctx.database.get(table, { platform });
+  return rows.filter((row) => normalizeId(String(row[field] ?? "")) === normalized);
+}
+__name(getRowsByNormalizedId, "getRowsByNormalizedId");
+async function getBlacklistedGuild(ctx, guildId) {
+  guildId = normalizeId(guildId);
+  const rows = await ctx.database.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  return rows.length > 0 ? rows : await getRowsByNormalizedId(ctx, "blacklisted_guild", "guildId", BLACKLIST_PLATFORM, guildId);
+}
+__name(getBlacklistedGuild, "getBlacklistedGuild");
+async function removeBlacklistedGuild(ctx, guildId) {
+  guildId = normalizeId(guildId);
+  const rows = await getRowsByNormalizedId(ctx, "blacklisted_guild", "guildId", BLACKLIST_PLATFORM, guildId);
+  await ctx.database.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId });
+  for (const row of rows) {
+    if (row.guildId !== guildId) {
+      await ctx.database.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM, guildId: row.guildId });
+    }
+  }
+  return rows.length > 0;
+}
+__name(removeBlacklistedGuild, "removeBlacklistedGuild");
+async function createBlacklistedGuild(ctx, guildId, reason) {
+  guildId = normalizeId(guildId);
+  return await ctx.database.upsert("blacklisted_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    timestamp: Math.floor(Date.now() / 1e3),
+    reason
+  }]);
+}
+__name(createBlacklistedGuild, "createBlacklistedGuild");
+async function getAllBlacklistedGuilds(ctx) {
+  return await ctx.database.get("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
+}
+__name(getAllBlacklistedGuilds, "getAllBlacklistedGuilds");
+async function clearBlacklistedGuilds(ctx) {
+  return await ctx.database.remove("blacklisted_guild", { platform: BLACKLIST_PLATFORM });
+}
+__name(clearBlacklistedGuilds, "clearBlacklistedGuilds");
+async function blacklistKicked(ctx, guildId) {
+  guildId = normalizeId(guildId);
+  return await ctx.database.upsert("blacklisted_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    timestamp: Math.floor(Date.now() / 1e3),
+    reason: "kicked"
+  }]);
+}
+__name(blacklistKicked, "blacklistKicked");
+async function markSelfLeft(ctx, guildId, selfId) {
+  selfId = normalizeId(selfId);
+  guildId = scopedId(guildId, selfId);
+  await ctx.database.upsert("self_left_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    selfId,
+    timestamp: Math.floor(Date.now() / 1e3)
+  }]);
+}
+__name(markSelfLeft, "markSelfLeft");
+async function consumeSelfLeft(ctx, guildId, selfId, maxAgeSec = 120) {
+  selfId = normalizeId(selfId);
+  const normalizedGuildId = normalizeId(guildId);
+  const scopedQuery = { platform: BLACKLIST_PLATFORM, guildId: scopedId(guildId, selfId) };
+  const legacyQuery = { platform: BLACKLIST_PLATFORM, guildId: normalizedGuildId };
+  const [row] = await ctx.database.get("self_left_guild", scopedQuery);
+  const [legacyRow] = row ? [] : await ctx.database.get("self_left_guild", legacyQuery);
+  const [prefixedLegacyRow] = row || legacyRow ? [] : await getRowsByNormalizedId(ctx, "self_left_guild", "guildId", BLACKLIST_PLATFORM, guildId);
+  const target = row ?? legacyRow ?? prefixedLegacyRow;
+  const query = row ? scopedQuery : { platform: BLACKLIST_PLATFORM, guildId: target?.guildId ?? normalizedGuildId };
+  if (!target) return false;
+  await ctx.database.remove("self_left_guild", query);
+  return Math.floor(Date.now() / 1e3) - target.timestamp <= maxAgeSec;
+}
+__name(consumeSelfLeft, "consumeSelfLeft");
+async function clearSelfLeft(ctx, guildId, selfId) {
+  const normalizedGuildId = normalizeId(guildId);
+  if (selfId) {
+    const normalizedSelfId = normalizeId(selfId);
+    await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId: scopedId(guildId, normalizedSelfId) });
+    await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId: normalizedGuildId });
+    const rows2 = await getRowsByNormalizedId(ctx, "self_left_guild", "guildId", BLACKLIST_PLATFORM, guildId);
+    for (const row of rows2) {
+      if (!isScopedId(row.guildId)) {
+        await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId: row.guildId });
+      }
+    }
+    return;
+  }
+  const rows = await ctx.database.get("self_left_guild", { platform: BLACKLIST_PLATFORM });
+  for (const row of rows) {
+    if (unscopedId(row.guildId) === normalizedGuildId) {
+      await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, guildId: row.guildId });
+    }
+  }
+}
+__name(clearSelfLeft, "clearSelfLeft");
+async function clearExpiredSelfLeft(ctx, maxAgeSec = 300) {
+  const cutoff = Math.floor(Date.now() / 1e3) - maxAgeSec;
+  await ctx.database.remove("self_left_guild", { platform: BLACKLIST_PLATFORM, timestamp: { $lt: cutoff } });
+}
+__name(clearExpiredSelfLeft, "clearExpiredSelfLeft");
+async function getCommandFrequencyRecord(ctx, platform, guildId) {
+  const records = await ctx.database.get("command_frequency_record", { platform, guildId });
+  return records.length > 0 ? records[0] : null;
+}
+__name(getCommandFrequencyRecord, "getCommandFrequencyRecord");
+async function updateCommandFrequencyRecord(ctx, platform, guildId, data) {
+  await ctx.database.upsert("command_frequency_record", [{
+    platform,
+    guildId,
+    ...data
+  }]);
+}
+__name(updateCommandFrequencyRecord, "updateCommandFrequencyRecord");
+var GROUP_BOT_STATUS_CACHE_TTL = 5 * 60 * 1e3;
+var GROUP_BOT_STATUS_CACHE_MAX = 1e3;
+var groupBotStatusCache = new SimpleLRUCache(GROUP_BOT_STATUS_CACHE_TTL, GROUP_BOT_STATUS_CACHE_MAX);
+var groupBotStatusCacheKey = /* @__PURE__ */ __name((platform, guildId) => `${platform}:${guildId}`, "groupBotStatusCacheKey");
+function getCachedGroupBotStatus(key) {
+  return groupBotStatusCache.get(key);
+}
+__name(getCachedGroupBotStatus, "getCachedGroupBotStatus");
+function setCachedGroupBotStatus(key, value) {
+  groupBotStatusCache.set(key, value);
+}
+__name(setCachedGroupBotStatus, "setCachedGroupBotStatus");
+async function getGroupBotStatus(ctx, platform, guildId) {
+  guildId = normalizeId(guildId);
+  const key = groupBotStatusCacheKey(platform, guildId);
+  const cached = getCachedGroupBotStatus(key);
+  if (cached !== void 0) return cached;
+  const records = await ctx.database.get("group_bot_status", { platform, guildId });
+  const legacyRecords = records.length > 0 ? [] : await getRowsByNormalizedId(ctx, "group_bot_status", "guildId", platform, guildId);
+  const status = records.length > 0 ? records[0] : legacyRecords.length > 0 ? {
+    ...legacyRecords[0],
+    guildId
+  } : null;
+  setCachedGroupBotStatus(key, status);
+  return status;
+}
+__name(getGroupBotStatus, "getGroupBotStatus");
+async function setGroupBotStatus(ctx, platform, guildId, botEnabled) {
+  guildId = normalizeId(guildId);
+  await ctx.database.upsert("group_bot_status", [{ platform, guildId, botEnabled }]);
+  setCachedGroupBotStatus(groupBotStatusCacheKey(platform, guildId), { platform, guildId, botEnabled });
+}
+__name(setGroupBotStatus, "setGroupBotStatus");
+async function isInSmallGroupWhitelist(ctx, guildId) {
+  guildId = normalizeId(guildId);
+  const records = await ctx.database.get("small_group_whitelist", { platform: BLACKLIST_PLATFORM, guildId });
+  return records.length > 0;
+}
+__name(isInSmallGroupWhitelist, "isInSmallGroupWhitelist");
+async function addToSmallGroupWhitelist(ctx, guildId) {
+  guildId = normalizeId(guildId);
+  await ctx.database.upsert("small_group_whitelist", [{ platform: BLACKLIST_PLATFORM, guildId }]);
+}
+__name(addToSmallGroupWhitelist, "addToSmallGroupWhitelist");
+async function removeFromSmallGroupWhitelist(ctx, guildId) {
+  guildId = normalizeId(guildId);
+  await ctx.database.remove("small_group_whitelist", { platform: BLACKLIST_PLATFORM, guildId });
+}
+__name(removeFromSmallGroupWhitelist, "removeFromSmallGroupWhitelist");
+async function getAllSmallGroupWhitelist(ctx) {
+  return await ctx.database.get("small_group_whitelist", { platform: BLACKLIST_PLATFORM });
+}
+__name(getAllSmallGroupWhitelist, "getAllSmallGroupWhitelist");
+async function markApprovedGuild(ctx, guildId, selfId) {
+  selfId = normalizeId(selfId);
+  guildId = scopedId(guildId, selfId);
+  await ctx.database.upsert("approved_guild", [{
+    platform: BLACKLIST_PLATFORM,
+    guildId,
+    selfId,
+    timestamp: Math.floor(Date.now() / 1e3)
+  }]);
+}
+__name(markApprovedGuild, "markApprovedGuild");
+async function isApprovedGuild(ctx, guildId, selfId) {
+  selfId = normalizeId(selfId);
+  const records = await ctx.database.get("approved_guild", { platform: BLACKLIST_PLATFORM, guildId: scopedId(guildId, selfId) });
+  if (records.length > 0) return true;
+  const legacyRecords = await ctx.database.get("approved_guild", { platform: BLACKLIST_PLATFORM, guildId: normalizeId(guildId) });
+  if (legacyRecords.length > 0) return true;
+  const prefixedLegacyRecords = await getRowsByNormalizedId(ctx, "approved_guild", "guildId", BLACKLIST_PLATFORM, guildId);
+  return prefixedLegacyRecords.some((row) => !isScopedId(row.guildId));
+}
+__name(isApprovedGuild, "isApprovedGuild");
+async function clearApprovedGuild(ctx, guildId, selfId) {
+  const normalizedGuildId = normalizeId(guildId);
+  if (selfId) {
+    await ctx.database.remove("approved_guild", { platform: BLACKLIST_PLATFORM, guildId: scopedId(guildId, selfId) });
+    await ctx.database.remove("approved_guild", { platform: BLACKLIST_PLATFORM, guildId: normalizedGuildId });
+    const rows2 = await getRowsByNormalizedId(ctx, "approved_guild", "guildId", BLACKLIST_PLATFORM, guildId);
+    for (const row of rows2) {
+      if (!isScopedId(row.guildId)) {
+        await ctx.database.remove("approved_guild", { platform: BLACKLIST_PLATFORM, guildId: row.guildId });
+      }
+    }
+    return;
+  }
+  const rows = await ctx.database.get("approved_guild", { platform: BLACKLIST_PLATFORM });
+  for (const row of rows) {
+    if (unscopedId(row.guildId) === normalizedGuildId) {
+      await ctx.database.remove("approved_guild", { platform: BLACKLIST_PLATFORM, guildId: row.guildId });
+    }
+  }
+}
+__name(clearApprovedGuild, "clearApprovedGuild");
+async function getPendingInvite(ctx, platform, groupId, selfId) {
+  selfId = normalizeId(selfId);
+  const records = await ctx.database.get("pending_invite", { platform, groupId: scopedId(groupId, selfId) });
+  if (records.length > 0) return decodePendingInvite(records[0]);
+  const legacyRecords = await ctx.database.get("pending_invite", { platform, groupId: normalizeId(groupId) });
+  if (legacyRecords.length > 0) return decodePendingInvite(legacyRecords[0]);
+  const prefixedLegacyRecords = await getRowsByNormalizedId(ctx, "pending_invite", "groupId", platform, groupId);
+  const prefixedLegacyRecord = prefixedLegacyRecords.find((row) => !isScopedId(row.groupId));
+  return prefixedLegacyRecord ? decodePendingInvite(prefixedLegacyRecord) : null;
+}
+__name(getPendingInvite, "getPendingInvite");
+async function addPendingInvite(ctx, platform, selfId, inviteUser) {
+  selfId = normalizeId(selfId);
+  await ctx.database.upsert("pending_invite", [{
+    platform,
+    selfId,
+    ...inviteUser,
+    groupId: scopedId(inviteUser.groupId, selfId),
+    userId: normalizeId(inviteUser.userId)
+  }]);
+}
+__name(addPendingInvite, "addPendingInvite");
+async function removePendingInvite(ctx, platform, groupId, selfId) {
+  selfId = normalizeId(selfId);
+  await ctx.database.remove("pending_invite", { platform, groupId: scopedId(groupId, selfId) });
+  await ctx.database.remove("pending_invite", { platform, groupId: normalizeId(groupId) });
+  const rows = await getRowsByNormalizedId(ctx, "pending_invite", "groupId", platform, groupId);
+  for (const row of rows) {
+    if (!isScopedId(row.groupId)) {
+      await ctx.database.remove("pending_invite", { platform, groupId: row.groupId });
+    }
+  }
+}
+__name(removePendingInvite, "removePendingInvite");
+async function getAllPendingInvites(ctx, platform, selfId) {
+  selfId = normalizeId(selfId);
+  const rows = await ctx.database.get("pending_invite", { platform });
+  return rows.filter((row) => row.selfId ? normalizeId(row.selfId) === selfId : !isScopedId(row.groupId)).map(decodePendingInvite);
+}
+__name(getAllPendingInvites, "getAllPendingInvites");
+async function clearExpiredPendingInvites(ctx, platform, expireTimeMs) {
+  const cutoff = Math.floor((Date.now() - expireTimeMs) / 1e3);
+  await ctx.database.remove("pending_invite", { platform, time: { $lt: cutoff } });
+}
+__name(clearExpiredPendingInvites, "clearExpiredPendingInvites");
+async function getPendingFriendRequest(ctx, platform, selfId, userId) {
+  selfId = normalizeId(selfId);
+  const records = await ctx.database.get("pending_friend_request", { platform, userId: scopedId(userId, selfId) });
+  if (records.length > 0) return decodePendingFriendRequest(records[0]);
+  const legacyRecords = await ctx.database.get("pending_friend_request", { platform, userId: normalizeId(userId) });
+  if (legacyRecords.length > 0) return decodePendingFriendRequest(legacyRecords[0]);
+  const prefixedLegacyRecords = await getRowsByNormalizedId(ctx, "pending_friend_request", "userId", platform, userId);
+  const prefixedLegacyRecord = prefixedLegacyRecords.find((row) => !isScopedId(row.userId));
+  return prefixedLegacyRecord ? decodePendingFriendRequest(prefixedLegacyRecord) : null;
+}
+__name(getPendingFriendRequest, "getPendingFriendRequest");
+async function addPendingFriendRequest(ctx, platform, selfId, data) {
+  selfId = normalizeId(selfId);
+  await ctx.database.upsert("pending_friend_request", [{
+    platform,
+    selfId,
+    ...data,
+    userId: scopedId(data.userId, selfId)
+  }]);
+}
+__name(addPendingFriendRequest, "addPendingFriendRequest");
+async function removePendingFriendRequest(ctx, platform, selfId, userId) {
+  selfId = normalizeId(selfId);
+  await ctx.database.remove("pending_friend_request", { platform, userId: scopedId(userId, selfId) });
+  await ctx.database.remove("pending_friend_request", { platform, userId: normalizeId(userId) });
+  const rows = await getRowsByNormalizedId(ctx, "pending_friend_request", "userId", platform, userId);
+  for (const row of rows) {
+    if (!isScopedId(row.userId)) {
+      await ctx.database.remove("pending_friend_request", { platform, userId: row.userId });
+    }
+  }
+}
+__name(removePendingFriendRequest, "removePendingFriendRequest");
+async function getAllPendingFriendRequests(ctx, platform, selfId) {
+  selfId = normalizeId(selfId);
+  const rows = await ctx.database.get("pending_friend_request", { platform });
+  return rows.filter((row) => row.selfId ? normalizeId(row.selfId) === selfId : !isScopedId(row.userId)).map(decodePendingFriendRequest);
+}
+__name(getAllPendingFriendRequests, "getAllPendingFriendRequests");
+async function clearExpiredPendingFriendRequests(ctx, platform, selfId, expireTimeMs) {
+  const cutoff = Math.floor((Date.now() - expireTimeMs) / 1e3);
+  await ctx.database.remove("pending_friend_request", { platform, time: { $lt: cutoff } });
+}
+__name(clearExpiredPendingFriendRequests, "clearExpiredPendingFriendRequests");
+
+// src/modules/basic.ts
+var basic_exports = {};
+__export(basic_exports, {
+  apply: () => apply2,
+  name: () => name2
+});
+var name2 = "group-control-basic";
+function getBotSelfId(bot) {
+  const raw = String(bot?.selfId ?? bot?.userId ?? "");
+  return parseGuildId(raw) ?? raw;
+}
+__name(getBotSelfId, "getBotSelfId");
+function makeGuildKey(platform, selfId, guildId) {
+  return `${platform}:${selfId}:${guildId}`;
+}
+__name(makeGuildKey, "makeGuildKey");
+async function leaveGroup(bot, guildId) {
+  const groupId = toOneBotNumber(guildId);
+  if (groupId == null) throw new Error(`无效群号: ${guildId}`);
+  await bot.internal.setGroupLeave(groupId);
+}
+__name(leaveGroup, "leaveGroup");
+async function getGroupName(bot, guildId) {
+  try {
+    const groupId = toOneBotNumber(guildId);
+    const info = groupId == null ? null : await bot.internal?.getGroupInfo?.(groupId);
+    const data = info?.data ?? info;
+    if (data?.group_name) return data.group_name;
+  } catch {
+  }
+  try {
+    const info = await bot.getGuild(guildId);
+    if (info?.name) return info.name;
+    if (info?.group_name) return info.group_name;
+  } catch {
+  }
+  return "未知";
+}
+__name(getGroupName, "getGroupName");
+async function getGroupMemberList(bot, guildId) {
+  try {
+    const groupId = toOneBotNumber(guildId);
+    const raw = groupId == null ? null : await bot.internal?.getGroupMemberList?.(groupId);
+    const list = Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+    if (list.length > 0) return list;
+  } catch {
+  }
+  try {
+    const raw = await bot.getGuildMemberList?.(guildId);
+    return Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+  } catch {
+  }
+  return [];
+}
+__name(getGroupMemberList, "getGroupMemberList");
+function apply2(ctx, config) {
+  const quittingGuilds = /* @__PURE__ */ new Map();
+  const processedKicks = /* @__PURE__ */ new Map();
+  const processedAdds = /* @__PURE__ */ new Map();
+  const realtimeLastCheck = /* @__PURE__ */ new Map();
+  const QUITTING_EXPIRE_MS = 60 * 1e3;
+  const KICK_DEDUP_MS = 60 * 1e3;
+  const ADD_DEDUP_MS = 10 * 1e3;
+  const REALTIME_DEBOUNCE_MS = 1500;
+  const WELCOME_RETRY_DELAYS = [1e3, 3e3, 7e3];
+  function isRecent(map, key, ttl) {
+    const time = map.get(key);
+    if (!time) return false;
+    if (Date.now() - time <= ttl) return true;
+    map.delete(key);
+    return false;
+  }
+  __name(isRecent, "isRecent");
+  ctx.setInterval(() => {
+    const now = Date.now();
+    for (const [key, time] of quittingGuilds) {
+      if (now - time > QUITTING_EXPIRE_MS) quittingGuilds.delete(key);
+    }
+    for (const [key, time] of processedKicks) {
+      if (now - time > KICK_DEDUP_MS) processedKicks.delete(key);
+    }
+    for (const [key, time] of processedAdds) {
+      if (now - time > ADD_DEDUP_MS) processedAdds.delete(key);
+    }
+    for (const [key, time] of realtimeLastCheck) {
+      if (now - time > 5 * 60 * 1e3) realtimeLastCheck.delete(key);
+    }
+  }, 30 * 1e3);
+  ctx.setInterval(async () => {
+    try {
+      await clearExpiredSelfLeft(ctx);
+    } catch {
+    }
+  }, 5 * 60 * 1e3);
+  async function evaluateSmallGroup(bot, guildId) {
+    const threshold = config.basic.smallGroupThreshold;
+    const exclude = config.basic.smallGroupExcludeOfficialBots;
+    const maxBots = 20;
+    let total = 0;
+    let groupName = "未知";
+    try {
+      const groupId = toOneBotNumber(guildId);
+      const info = groupId == null ? null : await bot.internal?.getGroupInfo?.(groupId);
+      const data = info?.data ?? info;
+      total = Number(data?.member_count) || 0;
+      if (data?.group_name) groupName = data.group_name;
+    } catch {
+    }
+    if (total === 0) {
+      try {
+        const guildInfo = await bot.getGuild(guildId);
+        total = Number(guildInfo?.member_count ?? guildInfo?.memberCount) || 0;
+        if (guildInfo?.name) groupName = guildInfo.name;
+      } catch {
+      }
+    }
+    if (total > 0 && total <= threshold) {
+      return { decision: "quit", count: total, groupName };
+    }
+    if (!exclude) {
+      if (total > 0) return { decision: total <= threshold ? "quit" : "keep", count: total, groupName };
+    } else if (total > threshold + maxBots) {
+      return { decision: "keep", count: total, groupName };
+    }
+    const list = await getGroupMemberList(bot, guildId);
+    if (list.length === 0) {
+      if (total > 0) return { decision: total <= threshold ? "quit" : "keep", count: total, groupName };
+      return { decision: "unknown", count: 0, groupName };
+    }
+    const N = list.length;
+    if (!exclude) return { decision: N <= threshold ? "quit" : "keep", count: N, groupName };
+    if (N <= threshold) return { decision: "quit", count: N, groupName };
+    const selfId = getBotSelfId(bot);
+    const botsNeeded = N - threshold;
+    let bots = 0;
+    for (const m of list) {
+      const uid = parseGuildId(String(m?.user_id ?? m?.userId ?? m?.user?.id ?? "")) ?? "";
+      if (m?.is_robot === true || m?.user?.isBot === true || selfId && uid === selfId) {
+        bots++;
+        if (bots >= botsNeeded) {
+          return { decision: "quit", count: N - bots, groupName };
+        }
+      }
+    }
+    const real = N - bots;
+    return { decision: real <= threshold ? "quit" : "keep", count: real, groupName };
+  }
+  __name(evaluateSmallGroup, "evaluateSmallGroup");
+  async function performSmallGroupQuit(bot, platform, guildId, groupName, memberCount) {
+    const selfId = getBotSelfId(bot);
+    const dedupKey = makeGuildKey(platform, selfId, guildId);
+    const threshold = config.basic.smallGroupThreshold;
+    const quitMsg = config.basic.smallGroupQuitMessage.replaceAll("{memberCount}", memberCount.toString()).replaceAll("{threshold}", threshold.toString()).replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId);
+    try {
+      await bot.sendMessage(guildId, quitMsg, platform);
+    } catch (e) {
+    }
+    if (config.basic.smallGroupNotifyAdmin) {
+      const adminMsg = `小群自动退群
+群名称：${groupName}
+群号：${guildId}
+群成员数：${memberCount}人（阈值：${threshold}人）
+机器人已自动退出该群。`;
+      await notifyAdmins(bot, config, adminMsg);
+    }
+    quittingGuilds.set(dedupKey, Date.now());
+    await markSelfLeft(ctx, guildId, selfId);
+    try {
+      await leaveGroup(bot, guildId);
+    } catch (e) {
+      console.error(`小群自动退群失败 (群号: ${guildId}):`, e);
+      quittingGuilds.delete(dedupKey);
+      await clearSelfLeft(ctx, guildId, selfId);
+    }
+  }
+  __name(performSmallGroupQuit, "performSmallGroupQuit");
+  function sendWelcomeMessage(bot, platform, guildId, message, shouldStop) {
+    const logger = ctx.logger("group-control-basic");
+    const attempt = /* @__PURE__ */ __name(async (attemptIndex) => {
+      if (shouldStop()) return;
+      try {
+        await bot.sendMessage(guildId, message, platform);
+        if (attemptIndex > 0) {
+          logger.info(`[guild-added] 欢迎消息重试成功 guildId=${guildId}, attempt=${attemptIndex + 1}`);
+        }
+      } catch (error) {
+        if (shouldStop()) return;
+        const retryDelay = WELCOME_RETRY_DELAYS[attemptIndex];
+        if (retryDelay == null) {
+          logger.warn(`[guild-added] 欢迎消息发送失败 guildId=${guildId}, attempts=${attemptIndex + 1}`, error);
+          return;
+        }
+        logger.warn(`[guild-added] 欢迎消息发送失败，${retryDelay}ms 后重试 guildId=${guildId}, attempt=${attemptIndex + 1}`, error);
+        ctx.setTimeout(() => {
+          void attempt(attemptIndex + 1);
+        }, retryDelay);
+      }
+    }, "attempt");
+    void attempt(0);
+  }
+  __name(sendWelcomeMessage, "sendWelcomeMessage");
+  ctx.on("guild-added", async (session) => {
+    const { platform } = session;
+    const guildId = parseGuildId(session.guildId);
+    if (!guildId) return;
+    const selfId = getBotSelfId(session.bot);
+    ctx.logger("group-control-basic").info(`[guild-added] 触发！guildId=${guildId}, platform=${platform}`);
+    const addKey = makeGuildKey(platform, selfId, guildId);
+    if (isRecent(processedAdds, addKey, ADD_DEDUP_MS)) {
+      ctx.logger("group-control-basic").info(`[guild-added] 忽略重复事件 guildId=${guildId}`);
+      return;
+    }
+    processedAdds.set(addKey, Date.now());
+    if (config.basic.enableBlacklist) {
+      const [blacklisted] = await getBlacklistedGuild(ctx, guildId);
+      if (blacklisted) {
+        try {
+          await session.bot.sendMessage(guildId, config.basic.blacklistMessage, platform);
+        } catch (e) {
+        }
+        quittingGuilds.set(addKey, Date.now());
+        await markSelfLeft(ctx, guildId, selfId);
+        try {
+          await leaveGroup(session.bot, guildId);
+        } catch (e) {
+        }
+        return;
+      }
+    }
+    if (config.basic.smallGroupAutoQuit) {
+      const inWhitelist = await isInSmallGroupWhitelist(ctx, guildId);
+      const wasApproved = await isApprovedGuild(ctx, guildId, selfId);
+      const pendingInvite = await getPendingInvite(ctx, platform, guildId, selfId);
+      const hadPendingInvite = !!pendingInvite;
+      if (hadPendingInvite) await removePendingInvite(ctx, platform, guildId, selfId);
+      if (inWhitelist || wasApproved || hadPendingInvite) {
+      } else {
+        const delay = config.basic.smallGroupCheckDelay || 3e3;
+        ctx.setTimeout(async () => {
+          try {
+            const res = await evaluateSmallGroup(session.bot, guildId);
+            let groupName = res.groupName;
+            if (groupName === "未知") groupName = await getGroupName(session.bot, guildId);
+            if (res.decision === "quit") {
+              await performSmallGroupQuit(session.bot, platform, guildId, groupName, res.count);
+            } else if (res.decision === "keep") {
+              if (config.basic.smallGroupQualifiedNotifyAdmin) {
+                const qualifiedMsg = config.basic.smallGroupQualifiedMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", guildId).replaceAll("{memberCount}", res.count.toString()).replaceAll("{threshold}", config.basic.smallGroupThreshold.toString());
+                await notifyAdmins(session.bot, config, qualifiedMsg);
+              }
+            }
+          } catch (error) {
+            console.error(`小群自动退群检测失败 (群号: ${guildId}):`, error);
+          }
+        }, delay);
+      }
+    }
+    if (config.basic.welcomeMessage) {
+      sendWelcomeMessage(
+        session.bot,
+        platform,
+        guildId,
+        config.basic.welcomeMessage,
+        () => isRecent(quittingGuilds, addKey, QUITTING_EXPIRE_MS)
+      );
+    }
+  });
+  if (config.basic.smallGroupAutoQuit && config.basic.smallGroupRealtimeMonitor) {
+    ctx.on("guild-member-removed", async (session) => {
+      const { platform } = session;
+      const guildId = parseGuildId(session.guildId);
+      if (!guildId) return;
+      const selfId = getBotSelfId(session.bot);
+      const dedupKey = makeGuildKey(platform, selfId, guildId);
+      if (parseGuildId(session.userId) === selfId) return;
+      if (quittingGuilds.has(dedupKey)) return;
+      const cooldown = (config.basic.smallGroupRecheckCooldown || 60) * 1e3;
+      const now = Date.now();
+      if (now - (realtimeLastCheck.get(dedupKey) || 0) < cooldown) return;
+      realtimeLastCheck.set(dedupKey, now);
+      if (await isInSmallGroupWhitelist(ctx, guildId)) return;
+      if (await isApprovedGuild(ctx, guildId, selfId)) return;
+      ctx.setTimeout(async () => {
+        try {
+          if (quittingGuilds.has(dedupKey)) return;
+          const res = await evaluateSmallGroup(session.bot, guildId);
+          if (res.decision === "quit") {
+            let groupName = res.groupName;
+            if (groupName === "未知") groupName = await getGroupName(session.bot, guildId);
+            await performSmallGroupQuit(session.bot, platform, guildId, groupName, res.count);
+          }
+        } catch (error) {
+          console.error(`实时小群检测失败 (群号: ${guildId}):`, error);
+        }
+      }, REALTIME_DEBOUNCE_MS);
+    });
+  }
+  ctx.on("guild-removed", async (session) => {
+    const guildId = parseGuildId(session.guildId);
+    if (!guildId) return;
+    const selfId = getBotSelfId(session.bot);
+    const platform = BLACKLIST_PLATFORM;
+    const dedupKey = makeGuildKey(platform, selfId, guildId);
+    try {
+      await clearApprovedGuild(ctx, guildId, selfId);
+    } catch {
+    }
+    if (quittingGuilds.has(dedupKey)) {
+      try {
+        await clearSelfLeft(ctx, guildId, selfId);
+      } catch {
+      }
+      return;
+    }
+    const isSelfLeft = await consumeSelfLeft(ctx, guildId, selfId);
+    if (isSelfLeft) return;
+    const raw = session.event?._data || session.original || session.onebot || {};
+    const subType = String(raw.sub_type ?? session.subtype ?? "");
+    const eventTs = typeof raw.time === "number" ? raw.time : Math.floor(Date.now() / 1e3);
+    const ageSec = Math.floor(Date.now() / 1e3) - eventTs;
+    if (subType === "leave") return;
+    if (!subType && ageSec > 60) return;
+    if (isRecent(processedKicks, dedupKey, KICK_DEDUP_MS)) return;
+    processedKicks.set(dedupKey, Date.now());
+    if (config.basic.enableBlacklist || config.basic.notifyAdminOnKick) {
+      const [existing] = await getBlacklistedGuild(ctx, guildId);
+      if (existing && existing.reason === "kicked") {
+        return;
+      }
+    }
+    if (config.basic.enableBlacklist) {
+      await blacklistKicked(ctx, guildId);
+    }
+    if (config.basic.notifyAdminOnKick) {
+      const groupName = await getGroupName(session.bot, guildId);
+      const kickMsg = config.basic.kickNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName);
+      await notifyAdmins(session.bot, config, kickMsg);
+    }
+  });
+  if (config.basic.notifyAdminOnMute || config.basic.muteAutoQuit) {
+    ctx.on("guild-member-mute", async (session) => {
+      const selfId = getBotSelfId(session.bot);
+      if (parseGuildId(session.userId) !== selfId) return;
+      if (!session.duration) return;
+      const { platform } = session;
+      const guildId = parseGuildId(session.guildId);
+      if (!guildId) return;
+      const operatorId = session.operatorId || "未知";
+      const duration = session.duration ?? 0;
+      const groupName = await getGroupName(session.bot, guildId);
+      if (config.basic.muteAutoQuit && duration >= config.basic.muteAutoQuitThreshold) {
+        const quitMsg = config.basic.muteQuitNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName).replaceAll("{operatorId}", operatorId).replaceAll("{duration}", duration.toString());
+        await notifyAdmins(session.bot, config, quitMsg);
+        try {
+          await createBlacklistedGuild(ctx, guildId, "muted");
+        } catch (e) {
+        }
+        const dedupKey = makeGuildKey(platform, selfId, guildId);
+        quittingGuilds.set(dedupKey, Date.now());
+        await markSelfLeft(ctx, guildId, selfId);
+        try {
+          await leaveGroup(session.bot, guildId);
+        } catch (e) {
+          console.error(`被禁言自动退群失败 (群号: ${guildId}):`, e);
+          quittingGuilds.delete(dedupKey);
+          await clearSelfLeft(ctx, guildId, selfId);
+        }
+        return;
+      }
+      if (config.basic.notifyAdminOnMute) {
+        const msg = config.basic.muteNotificationMessage.replaceAll("{groupId}", guildId).replaceAll("{groupName}", groupName).replaceAll("{operatorId}", operatorId).replaceAll("{duration}", duration.toString());
+        await notifyAdmins(session.bot, config, msg);
+      }
+    });
+  }
+  if (config.basic.quitCommandEnabled) {
+    const cmdOpts = getAdminCommandOptions(config);
+    ctx.command("quit", "让机器人主动退出当前群聊", cmdOpts).action(async ({ session }) => {
+      if (!session.guildId) return "quit 指令只能在群聊中使用。";
+      if (config.permission.mode === "builtin") {
+        const hasPerm = await hasGuildPermission(session, config);
+        if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
+      }
+      const { platform, userId } = session;
+      const guildId = parseGuildId(session.guildId);
+      if (!guildId) return "当前群号格式无效，无法退出。";
+      const selfId = getBotSelfId(session.bot);
+      const dedupKey = makeGuildKey(platform, selfId, guildId);
+      const groupName = await getGroupName(session.bot, guildId);
+      const adminMsg = `收到来自 ${userId} 的退群指令
+群名称：${groupName}
+群号：${guildId}`;
+      await notifyAdmins(session.bot, config, adminMsg);
+      quittingGuilds.set(dedupKey, Date.now());
+      await markSelfLeft(ctx, guildId, selfId);
+      try {
+        await session.bot.sendMessage(session.guildId, config.basic.quitMessage.replaceAll("{userId}", userId), platform);
+      } catch (e) {
+      }
+      try {
+        await leaveGroup(session.bot, guildId);
+      } catch (e) {
+        quittingGuilds.delete(dedupKey);
+        await clearSelfLeft(ctx, guildId, selfId);
+        return `退出失败: ${e.message}`;
+      }
+      return "";
+    });
+  }
+}
+__name(apply2, "apply");
+
+// src/modules/invite.ts
+var invite_exports = {};
+__export(invite_exports, {
+  apply: () => apply3,
+  name: () => name3
+});
+var name3 = "group-control-invite";
+function getBotSelfId2(bot) {
+  return parseGuildId(String(bot?.selfId ?? bot?.userId ?? ""));
+}
+__name(getBotSelfId2, "getBotSelfId");
+async function handleInviteRequest(bot, flag, approve, comment = "") {
+  if (typeof bot.handleGuildRequest === "function") {
+    try {
+      await bot.handleGuildRequest(flag, approve, comment);
+      return;
+    } catch {
+    }
+  }
+  await bot.internal.setGroupAddRequest(flag, "invite", approve, comment);
+}
+__name(handleInviteRequest, "handleInviteRequest");
+function apply3(ctx, config) {
+  if (!config.invite.enabled) return;
+  ctx.setInterval(async () => {
+    const expireMs = config.invite.inviteExpireDays * 24 * 60 * 60 * 1e3;
+    try {
+      for (const bot of ctx.bots) {
+        await clearExpiredPendingInvites(ctx, bot.platform, expireMs);
+      }
+      if (config.invite.showDetailedLog) {
+        console.log("已执行过期邀请清理");
+      }
+    } catch (error) {
+      console.error("清理过期邀请失败:", error);
+    }
+  }, 60 * 60 * 1e3);
+  ctx.logger("group-control-invite").info("invite 模块已加载，正在监听 guild-request 事件");
+  ctx.on("guild-request", async (session) => {
+    ctx.logger("group-control-invite").info(`[guild-request] 触发！userId=${session.userId}, guildId=${session.guildId}, messageId=${session.messageId}, type=${session.type}, subtype=${session.subtype}`);
+    ctx.logger("group-control-invite").info(`[guild-request] event 对象: ${JSON.stringify(session.event, null, 2)}`);
+    const raw = session.original || session.raw || session.event?._data || {};
+    const subType = String(raw.sub_type ?? session.subtype ?? "");
+    if (subType && subType !== "invite") return;
+    const flag = raw.flag || session.flag || session.messageId;
+    const rawUserId = raw.user_id ? String(raw.user_id) : session.userId;
+    const rawGroupId = raw.group_id ? String(raw.group_id) : session.guildId;
+    const userId = parseGuildId(rawUserId);
+    const groupId = parseGuildId(rawGroupId);
+    const selfId = getBotSelfId2(session.bot);
+    if (!userId || !groupId || !selfId) {
+      ctx.logger("group-control-invite").warn(`无法解析邀请事件 ID: userId=${rawUserId}, groupId=${rawGroupId}, selfId=${session.bot?.selfId}`);
+      return;
+    }
+    const { platform } = session;
+    if (config.basic.enableBlacklist) {
+      const bl = await getBlacklistedGuild(ctx, groupId);
+      if (bl.length > 0) {
+        try {
+          await handleInviteRequest(session.bot, flag, false, "该群已被机器人拉黑");
+        } catch (e) {
+          ctx.logger("group-control-invite").warn("拒绝黑名单群邀请失败 (flag 可能已失效):", e);
+        }
+        const rejectNotify = `已自动拒绝黑名单群邀请
+群号：${groupId}
+邀请者 QQ：${userId}
+如需放行请先执行 gc.unban ${groupId} 再让对方重新邀请。`;
+        try {
+          await notifyAdmins(session.bot, config, rejectNotify);
+        } catch (e) {
+        }
+        try {
+          const rejectMsg = `您邀请加入的群 ${groupId} 已被机器人拉黑，邀请已被自动拒绝。如有疑问请联系机器人管理员。`;
+          await session.bot.sendPrivateMessage(userId, rejectMsg);
+        } catch (e) {
+        }
+        if (config.invite.showDetailedLog) {
+          console.log(`已自动拒绝黑名单群邀请: 群号 ${groupId}, 邀请者 ${userId}`);
+        }
+        return;
+      }
+    }
+    if (!flag && config.invite.showDetailedLog) {
+      console.warn("未能提取到邀请 flag，可能导致无法处理邀请。Raw event:", JSON.stringify(raw));
+    }
+    if (config.invite.showDetailedLog) {
+      console.log(`收到群邀请事件 - 原始数据: UserID=${raw.user_id}, GroupID=${raw.group_id}, Flag=${flag}`);
+    }
+    let userName = userId;
+    try {
+      const userInfo = await session.bot.getUser(userId);
+      userName = userInfo?.nickname || userInfo?.name || userId;
+    } catch (error) {
+      console.error("获取用户信息失败:", error);
+    }
+    let groupName = groupId;
+    try {
+      const guildInfo = await session.bot.getGuild(groupId);
+      groupName = guildInfo?.name || guildInfo?.group_name || groupId;
+    } catch (error) {
+      console.error("获取群信息失败:", error);
+    }
+    if (config.invite.autoApprove) {
+      try {
+        await handleInviteRequest(session.bot, flag, true);
+        await markApprovedGuild(ctx, groupId, selfId);
+        if (config.invite.showDetailedLog) {
+          console.log(`自动同意群聊邀请: 群号 ${groupId}, 邀请者 ${userId}`);
+        }
+      } catch (error) {
+        console.error("自动同意群聊邀请失败:", error);
+        return;
+      }
+      try {
+        const approveMessage = config.invite.inviteApproveMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", groupId).replaceAll("{userName}", userName).replaceAll("{userId}", userId);
+        await session.bot.sendPrivateMessage(userId, approveMessage);
+      } catch (error) {
+        console.error(`发送自动通过提示给 ${userId} 失败:`, error);
+      }
+      if (config.invite.notifyAdminOnApprove) {
+        const notifyMessage = config.invite.inviteApproveNotificationMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", groupId).replaceAll("{userName}", userName).replaceAll("{userId}", userId);
+        await notifyAdmins(session.bot, config, notifyMessage);
+      }
+      return;
+    }
+    try {
+      const waitMessage = config.invite.inviteWaitMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", groupId).replaceAll("{userName}", userName).replaceAll("{userId}", userId);
+      await session.bot.sendPrivateMessage(userId, waitMessage);
+    } catch (error) {
+      console.error(`发送等待审核提示给 ${userId} 失败:`, error);
+    }
+    if (!config.admin.adminQQs || config.admin.adminQQs.length === 0) {
+      return;
+    }
+    await addPendingInvite(ctx, platform, selfId, {
+      groupId,
+      userId,
+      userName,
+      groupName,
+      time: Math.floor(Date.now() / 1e3),
+      flag
+    });
+    const requestMessage = config.invite.inviteRequestMessage.replaceAll("{groupName}", groupName).replaceAll("{groupId}", groupId).replaceAll("{userName}", userName).replaceAll("{userId}", userId);
+    await notifyAdmins(session.bot, config, requestMessage);
+    if (config.invite.showDetailedLog) {
+      console.log("已发送群邀请审核通知");
+    }
+  });
+  const cmdOpts = getAdminCommandOptions(config);
+  ctx.command("gc.approve <groupId:string>", "同意群聊邀请", cmdOpts).action(async ({ session }, groupId) => {
+    if (!groupId) return "请指定群号。用法：gc.approve <群号>";
+    groupId = parseGuildId(groupId);
+    if (!groupId) return "输入格式错误，请输入群号。";
+    const selfId = getBotSelfId2(session.bot);
+    if (!selfId) return "无法识别当前机器人账号，已取消操作。";
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有管理员可以审核邀请。";
+    if (config.basic.enableBlacklist) {
+      const bl = await getBlacklistedGuild(ctx, groupId);
+      if (bl.length > 0) {
+        return `群 ${groupId} 在黑名单中，无法通过审核。如需放行请先执行 gc.unban ${groupId}。`;
+      }
+    }
+    const inviteData = await getPendingInvite(ctx, session.platform, groupId, selfId);
+    if (!inviteData) {
+      const allInvites = await getAllPendingInvites(ctx, session.platform, selfId);
+      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${allInvites.length > 0 ? allInvites.map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
+    }
+    try {
+      await handleInviteRequest(session.bot, inviteData.flag, true);
+      await markApprovedGuild(ctx, groupId, selfId);
+      try {
+        await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请已通过管理员审核，机器人已加入群聊。`);
+      } catch (error) {
+        console.error("通知邀请者失败:", error);
+      }
+      await removePendingInvite(ctx, session.platform, groupId, selfId);
+      return `已同意加入群 ${groupId}（${inviteData.groupName}），邀请者：${inviteData.userName}`;
+    } catch (error) {
+      console.error("处理同意邀请失败:", error);
+      return `处理同意邀请失败: ${error.message}`;
+    }
+  });
+  ctx.command("gc.reject <groupId:string>", "拒绝群聊邀请", cmdOpts).action(async ({ session }, groupId) => {
+    if (!groupId) return "请指定群号。用法：gc.reject <群号>";
+    groupId = parseGuildId(groupId);
+    if (!groupId) return "输入格式错误，请输入群号。";
+    const selfId = getBotSelfId2(session.bot);
+    if (!selfId) return "无法识别当前机器人账号，已取消操作。";
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有管理员可以审核邀请。";
+    const inviteData = await getPendingInvite(ctx, session.platform, groupId, selfId);
+    if (!inviteData) {
+      const allInvites = await getAllPendingInvites(ctx, session.platform, selfId);
+      return `未找到群号 ${groupId} 的待处理邀请。当前待处理邀请：${allInvites.length > 0 ? allInvites.map((i) => `${i.groupId}(${i.groupName})`).join(", ") : "无"}`;
+    }
+    try {
+      await handleInviteRequest(session.bot, inviteData.flag, false, "已拒绝");
+      try {
+        await session.bot.sendPrivateMessage(inviteData.userId, `您的群聊邀请未通过管理员审核，机器人将不会加入该群聊。`);
+      } catch (error) {
+        console.error("通知邀请者失败:", error);
+      }
+      await removePendingInvite(ctx, session.platform, groupId, selfId);
+      return `已拒绝加入群 ${groupId}（${inviteData.groupName}），邀请者：${inviteData.userName}`;
+    } catch (error) {
+      console.error("处理拒绝邀请失败:", error);
+      return `处理拒绝邀请失败: ${error.message}`;
+    }
+  });
+  ctx.command("gc.pending", "查看待处理的群聊邀请", cmdOpts).action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) {
+      return "权限不足，只有管理员可以查看待处理邀请。";
+    }
+    const selfId = getBotSelfId2(session.bot);
+    if (!selfId) return "无法识别当前机器人账号，已取消操作。";
+    const allInvites = await getAllPendingInvites(ctx, session.platform, selfId);
+    if (allInvites.length === 0) {
+      return "当前没有待处理的群聊邀请。";
+    }
+    const lines = ["待处理的群聊邀请列表："];
+    for (const invite of allInvites) {
+      const elapsed = Math.floor((Date.now() / 1e3 - invite.time) / 60);
+      lines.push(`- 群：${invite.groupName}（${invite.groupId}）`);
+      lines.push(`  邀请者：${invite.userName}（${invite.userId}）`);
+      lines.push(`  ${elapsed} 分钟前`);
+      lines.push(`  同意：gc.approve ${invite.groupId} | 拒绝：gc.reject ${invite.groupId}`);
+    }
+    return lines.join("\n");
+  });
+}
+__name(apply3, "apply");
+
+// src/modules/frequency.ts
+var frequency_exports = {};
+__export(frequency_exports, {
+  apply: () => apply4,
+  name: () => name4
+});
+var name4 = "group-control-frequency";
+var PRIVATE_GUILD_PREFIX = "__private__:";
+var frequencyLocks = /* @__PURE__ */ new Map();
+function isBlocked(record) {
+  if (!record || !record.blockExpiryTime) return false;
+  return Date.now() < record.blockExpiryTime * 1e3;
+}
+__name(isBlocked, "isBlocked");
+function calcBlockDur(baseDur, expBase, blockCount) {
+  if (expBase <= 1) return baseDur;
+  return Math.round(baseDur * Math.pow(expBase, blockCount - 1));
+}
+__name(calcBlockDur, "calcBlockDur");
+function makeEmptyRecord(platform, guildId, now) {
+  return { platform, guildId, commandCount: 1, lastCommandTime: now, warningSent: false, blockExpiryTime: 0, firstWarningTime: 0, blockCount: 0, lastBlockNotifyTime: 0 };
+}
+__name(makeEmptyRecord, "makeEmptyRecord");
+async function withFrequencyLock(key, task) {
+  const previous = frequencyLocks.get(key) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  const tail = previous.then(() => current, () => current);
+  frequencyLocks.set(key, tail);
+  await previous.catch(() => {
+  });
+  try {
+    return await task();
+  } finally {
+    release();
+    if (frequencyLocks.get(key) === tail) frequencyLocks.delete(key);
+  }
+}
+__name(withFrequencyLock, "withFrequencyLock");
+async function handleTrigger(ctx, platform, guildId, limit, window, warnDelay, baseDur, expBase, expWindow, notifyCooldown) {
+  let record = await getCommandFrequencyRecord(ctx, platform, guildId);
+  const now = Math.floor(Date.now() / 1e3);
+  const windowStart = now - window;
+  if (!record) {
+    record = makeEmptyRecord(platform, guildId, now);
+  } else if (record.lastCommandTime < windowStart) {
+    if (isBlocked(record)) {
+    } else {
+      const blockExpired = record.blockExpiryTime > 0 && now - record.blockExpiryTime > expWindow;
+      record.commandCount = 1;
+      record.lastCommandTime = now;
+      record.warningSent = false;
+      record.firstWarningTime = 0;
+      if (blockExpired) record.blockCount = 0;
+    }
+  } else {
+    record.commandCount += 1;
+    record.lastCommandTime = now;
+  }
+  if (isBlocked(record)) {
+    const remaining = Math.ceil((record.blockExpiryTime * 1e3 - Date.now()) / 1e3);
+    const lastNotify = record.lastBlockNotifyTime || 0;
+    if (now - lastNotify >= notifyCooldown) {
+      record.lastBlockNotifyTime = now;
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "blocked", remaining };
+    } else {
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "blocked-silent" };
+    }
+  }
+  if (warnDelay > 0 && record.warningSent && record.firstWarningTime > 0 && now - record.firstWarningTime >= warnDelay) {
+    record.warningSent = false;
+    record.firstWarningTime = 0;
+    record.commandCount = 1;
+    record.lastCommandTime = now;
+  }
+  if (record.commandCount > limit) {
+    if (!record.warningSent) {
+      record.warningSent = true;
+      record.commandCount = 1;
+      record.lastCommandTime = now;
+      record.firstWarningTime = now;
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "warn" };
+    } else {
+      record.blockCount = (record.blockCount || 0) + 1;
+      const dur = calcBlockDur(baseDur, expBase, record.blockCount);
+      record.blockExpiryTime = now + dur;
+      record.warningSent = false;
+      record.commandCount = 0;
+      record.firstWarningTime = 0;
+      record.lastBlockNotifyTime = now;
+      await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+      return { result: "new-blocked", dur };
+    }
+  }
+  await updateCommandFrequencyRecord(ctx, platform, guildId, record);
+  return { result: "ok" };
+}
+__name(handleTrigger, "handleTrigger");
+function isSystemSession(session) {
+  if (!session.userId) return true;
+  if (session.userId === session.bot?.userId) return true;
+  return false;
+}
+__name(isSystemSession, "isSystemSession");
+function isUserInitiatedNonCommand(session) {
+  if (!session.content) return false;
+  const mentioned = session.elements?.some((e) => e.type === "at" && e.attrs?.id === session.bot?.userId);
+  if (mentioned) return true;
+  if (!session.guildId) return true;
+  return false;
+}
+__name(isUserInitiatedNonCommand, "isUserInitiatedNonCommand");
+function apply4(ctx, config) {
+  const freq = config.frequency;
+  if (!freq.enabled && !freq.privateEnabled) return;
+  const groupWhitelist = new Set((freq.whitelist ?? []).map((id) => parseGuildId(id) ?? id));
+  const privateWhitelist = new Set((freq.privateWhitelist ?? []).map((id) => parseGuildId(id) ?? id));
+  const countedSessions = /* @__PURE__ */ new WeakSet();
+  async function checkFrequency(session, isCommand) {
+    const isPrivate = !session.guildId;
+    const platform = session.platform;
+    if (isPrivate) {
+      if (!freq.privateEnabled) return true;
+      const userId = parseGuildId(session.userId) ?? session.userId;
+      if (privateWhitelist.has(userId)) return true;
+      const guildId = PRIVATE_GUILD_PREFIX + userId;
+      const r = await withFrequencyLock(`${platform}:${guildId}`, () => handleTrigger(
+        ctx,
+        platform,
+        guildId,
+        freq.privateLimit,
+        freq.privateWindow,
+        freq.privateWarnDelay,
+        freq.privateBlockDur,
+        freq.blockExpBase,
+        freq.blockExpWindow,
+        freq.blockNotifyCooldown
+      ));
+      if (r.result === "ok") return true;
+      if (r.result === "warn") {
+        try {
+          await session.send(freq.warnMsg);
+        } catch (e) {
+        }
+        return false;
+      }
+      if (r.result === "new-blocked") {
+        try {
+          await session.send(freq.blockMsg.replace("{duration}", r.dur.toString()));
+        } catch (e) {
+        }
+        return false;
+      }
+      if (r.result === "blocked") {
+        try {
+          await session.send(freq.blockedMsg.replace("{time}", r.remaining.toString()));
+        } catch (e) {
+        }
+        return false;
+      }
+      return false;
+    } else {
+      if (!freq.enabled) return true;
+      const normalizedGuildId = parseGuildId(session.guildId) ?? session.guildId;
+      if (groupWhitelist.has(normalizedGuildId)) return true;
+      const guildId = normalizedGuildId;
+      const r = await withFrequencyLock(`${platform}:${guildId}`, () => handleTrigger(
+        ctx,
+        platform,
+        guildId,
+        freq.limit,
+        freq.window,
+        freq.warnDelay,
+        freq.blockDur,
+        freq.blockExpBase,
+        freq.blockExpWindow,
+        freq.blockNotifyCooldown
+      ));
+      if (r.result === "ok") return true;
+      if (r.result === "warn") {
+        try {
+          await session.bot.sendMessage(guildId, freq.warnMsg, platform);
+        } catch (e) {
+        }
+        return false;
+      }
+      if (r.result === "new-blocked") {
+        try {
+          await session.bot.sendMessage(guildId, freq.blockMsg.replace("{duration}", r.dur.toString()), platform);
+        } catch (e) {
+        }
+        return false;
+      }
+      if (r.result === "blocked") {
+        try {
+          await session.bot.sendMessage(guildId, freq.blockedMsg.replace("{time}", r.remaining.toString()), platform);
+        } catch (e) {
+        }
+        return false;
+      }
+      return false;
+    }
+  }
+  __name(checkFrequency, "checkFrequency");
+  ctx.on("command/before-execute", async (argv) => {
+    const session = argv.session;
+    if (isSystemSession(session)) return;
+    if (countedSessions.has(session)) return;
+    const allowed = await checkFrequency(session, true);
+    if (!allowed) return "";
+  });
+  ctx.middleware(async (session, next) => {
+    if (isSystemSession(session)) return next();
+    if (!isUserInitiatedNonCommand(session)) return next();
+    countedSessions.add(session);
+    const allowed = await checkFrequency(session, false);
+    if (!allowed) return;
+    return next();
+  }, true);
+}
+__name(apply4, "apply");
+
+// src/modules/commands.ts
+var commands_exports = {};
+__export(commands_exports, {
+  apply: () => apply5,
+  name: () => name5
+});
+var name5 = "group-control-commands";
+function chunk(arr, size) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
+  return out;
+}
+__name(chunk, "chunk");
+async function sendAsForward(session, title, lines) {
+  const groups = chunk(lines, 80);
+  const botId = String(session.bot?.selfId || "10000");
+  const nodes = groups.map((g) => ({
+    type: "node",
+    data: { user_id: botId, nickname: title, content: g.join("\n") }
+  }));
+  try {
+    const internal = session.bot.internal;
+    if (session.guildId) {
+      if (typeof internal.sendGroupForwardMsg !== "function") throw new Error("no forward api");
+      const guildId = toOneBotNumber(session.guildId);
+      if (guildId == null) throw new Error("invalid guild id");
+      await internal.sendGroupForwardMsg(guildId, nodes);
+    } else {
+      if (typeof internal.sendPrivateForwardMsg !== "function") throw new Error("no forward api");
+      const userId = toOneBotNumber(session.userId);
+      if (userId == null) throw new Error("invalid user id");
+      await internal.sendPrivateForwardMsg(userId, nodes);
+    }
+  } catch {
+    for (const g of groups) {
+      try {
+        await session.send(g.join("\n"));
+      } catch {
+      }
+    }
+  }
+}
+__name(sendAsForward, "sendAsForward");
+async function deleteFriendCompat(bot, userId) {
+  const internal = bot.internal;
+  if (typeof internal?.deleteFriend !== "function") {
+    throw new Error("当前适配器不支持 delete_friend 接口");
+  }
+  const n = toOneBotNumber(userId);
+  if (n == null) throw new Error("输入格式错误，请输入要删除的好友 QQ 号。");
+  try {
+    await internal.deleteFriend(n);
+  } catch (e) {
+    await internal.deleteFriend({ user_id: n, friend_id: n, temp_block: false, both_del: false });
+  }
+}
+__name(deleteFriendCompat, "deleteFriendCompat");
+function apply5(ctx, config) {
+  const cmdOpts = getAdminCommandOptions(config);
+  ctx.command("gc", "群控管理员指令", cmdOpts);
+  ctx.command("gc.ban <groupId:text>", "添加群聊到黑名单", cmdOpts).action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const errorMsg = isBlacklistEnabled(config.basic);
+    if (errorMsg) return errorMsg;
+    const guildId = parseGuildId(input);
+    if (!guildId) return `输入格式错误。`;
+    const existing = await getBlacklistedGuild(ctx, guildId);
+    if (existing.length > 0) return `群聊 ${guildId} 已在黑名单中。`;
+    await createBlacklistedGuild(ctx, guildId, "manual_add");
+    return `已添加群聊 ${guildId} 到黑名单。`;
+  });
+  ctx.command("gc.unban <groupId:text>", "从黑名单移除群聊", cmdOpts).action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const errorMsg = isBlacklistEnabled(config.basic);
+    if (errorMsg) return errorMsg;
+    const guildId = parseGuildId(input);
+    if (!guildId) return `输入格式错误。`;
+    const removed = await removeBlacklistedGuild(ctx, guildId);
+    await clearSelfLeft(ctx, guildId);
+    return removed ? `已移除群聊 ${guildId}` : `群聊 ${guildId} 不在黑名单中。`;
+  });
+  ctx.command("gc.banlist", "查看黑名单", cmdOpts).action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const errorMsg = isBlacklistEnabled(config.basic);
+    if (errorMsg) return errorMsg;
+    const records = await getAllBlacklistedGuilds(ctx);
+    if (records.length === 0) return "黑名单为空。";
+    return "黑名单列表：\n" + records.map((r) => `- ${r.guildId} (时间: ${formatDate(r.timestamp)})`).join("\n");
+  });
+  ctx.command("gc.clearban", "清空黑名单", cmdOpts).action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const errorMsg = isBlacklistEnabled(config.basic);
+    if (errorMsg) return errorMsg;
+    const records = await getAllBlacklistedGuilds(ctx);
+    if (records.length === 0) return "黑名单已是空的。";
+    await clearBlacklistedGuilds(ctx);
+    return `已清空黑名单，共移除 ${records.length} 个群聊。`;
+  });
+  ctx.command("gc.sg-add <groupId:text>", "解除指定群聊的小群人数限制", cmdOpts).action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const guildId = parseGuildId(input);
+    if (!guildId) return "输入格式错误，请输入群号。";
+    const exists = await isInSmallGroupWhitelist(ctx, guildId);
+    if (exists) return `群聊 ${guildId} 已在小群白名单中。`;
+    await addToSmallGroupWhitelist(ctx, guildId);
+    return `已将群聊 ${guildId} 加入小群白名单，该群不再受小群人数限制。`;
+  });
+  ctx.command("gc.sg-rm <groupId:text>", "恢复指定群聊的小群人数限制", cmdOpts).action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const guildId = parseGuildId(input);
+    if (!guildId) return "输入格式错误，请输入群号。";
+    const exists = await isInSmallGroupWhitelist(ctx, guildId);
+    if (!exists) return `群聊 ${guildId} 不在小群白名单中。`;
+    await removeFromSmallGroupWhitelist(ctx, guildId);
+    return `已将群聊 ${guildId} 从小群白名单移除，该群将恢复小群人数限制。`;
+  });
+  ctx.command("gc.sg-list", "查看小群白名单", cmdOpts).action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const records = await getAllSmallGroupWhitelist(ctx);
+    if (records.length === 0) return "小群白名单为空。";
+    return "小群白名单列表（以下群不受小群人数限制）：\n" + records.map((r) => `- ${r.guildId}`).join("\n");
+  });
+  ctx.command("gc.friends", "列出机器人的好友（合并转发）", cmdOpts).action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    let list = [];
+    try {
+      const raw = await session.bot.internal.getFriendList();
+      list = Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+    } catch (e) {
+      return `获取好友列表失败：${e.message}`;
+    }
+    if (list.length === 0) return "好友列表为空。";
+    const lines = list.map((f, i) => {
+      const uid = f.user_id ?? f.userId ?? "";
+      const name9 = f.remark || f.nickname || f.nick || String(uid);
+      return `${i + 1}. ${name9} (${uid})`;
+    });
+    await sendAsForward(session, `好友列表（共 ${list.length} 个）`, lines);
+    return "";
+  });
+  ctx.command("gc.delfriend <userId:text>", "删除指定好友", cmdOpts).action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const userId = parseGuildId(input);
+    if (!userId) return "输入格式错误，请输入要删除的好友 QQ 号。";
+    try {
+      await deleteFriendCompat(session.bot, userId);
+      return `已删除好友 ${userId}。`;
+    } catch (e) {
+      return `删除好友失败：${e.message}`;
+    }
+  });
+  ctx.command("gc.groups", "列出机器人所在的群（合并转发）", cmdOpts).action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    let list = [];
+    try {
+      const raw = await session.bot.internal.getGroupList();
+      list = Array.isArray(raw) ? raw : Array.isArray(raw?.data) ? raw.data : [];
+    } catch (e) {
+      return `获取群列表失败：${e.message}`;
+    }
+    if (list.length === 0) return "机器人尚未加入任何群。";
+    const lines = list.map((g, i) => {
+      const gid = g.group_id ?? g.groupId ?? "";
+      const gname = g.group_name ?? g.groupName ?? String(gid);
+      const count = g.member_count ?? g.memberCount;
+      const max = g.max_member_count ?? g.maxMemberCount;
+      const sizeInfo = count != null ? `（${count}${max != null ? `/${max}` : ""}人）` : "";
+      return `${i + 1}. ${gname} (${gid})${sizeInfo}`;
+    });
+    await sendAsForward(session, `群列表（共 ${list.length} 个）`, lines);
+    return "";
+  });
+  ctx.command("gc.leave <groupId:text>", "让机器人退出指定群", cmdOpts).action(async ({ session }, input) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足，只有全局管理员可以执行此操作。";
+    const guildId = parseGuildId(input);
+    if (!guildId) return "输入格式错误，请输入要退出的群号。";
+    const selfId = parseGuildId(String(session.bot?.selfId ?? session.bot?.userId ?? ""));
+    if (!selfId) return "无法识别当前机器人账号，已取消退群。";
+    await markSelfLeft(ctx, guildId, selfId);
+    try {
+      const groupId = toOneBotNumber(guildId);
+      if (groupId == null) throw new Error("无效群号");
+      await session.bot.internal.setGroupLeave(groupId);
+      return `已退出群 ${guildId}。`;
+    } catch (e) {
+      await clearSelfLeft(ctx, guildId, selfId);
+      return `退出群 ${guildId} 失败：${e.message}`;
+    }
+  });
+}
+__name(apply5, "apply");
+
+// src/modules/switch.ts
+var switch_exports = {};
+__export(switch_exports, {
+  apply: () => apply6,
+  name: () => name6
+});
+var name6 = "group-control-switch";
+function normalizeCommandName(name9, prefixes = []) {
+  let source = name9.trim();
+  for (const prefix of prefixes.filter(Boolean).sort((a, b) => b.length - a.length)) {
+    if (source.startsWith(prefix)) {
+      source = source.slice(prefix.length);
+      break;
+    }
+  }
+  return source.replace(/^[/.!！。]+/, "").toLowerCase().replace(/_/g, "-");
+}
+__name(normalizeCommandName, "normalizeCommandName");
+function getCommandNames(command) {
+  const names = /* @__PURE__ */ new Set();
+  if (command?.name) names.add(normalizeCommandName(command.name));
+  if (command?.displayName) names.add(normalizeCommandName(command.displayName));
+  for (const alias of Object.keys(command?._aliases ?? {})) {
+    names.add(normalizeCommandName(alias));
+  }
+  return [...names];
+}
+__name(getCommandNames, "getCommandNames");
+function isAdminCommand(command) {
+  return getCommandNames(command).some((commandName) => ADMIN_COMMANDS.has(commandName));
+}
+__name(isAdminCommand, "isAdminCommand");
+function getCommandPrefixes(ctx, session) {
+  const configured = session.resolve?.(ctx.root.config.prefix) ?? ctx.root.config.prefix;
+  const prefixes = Array.isArray(configured) ? configured : [configured || ""];
+  return [...prefixes, "/", ".", "!", "！", "。"];
+}
+__name(getCommandPrefixes, "getCommandPrefixes");
+function stripLeadingBotMentions(content) {
+  return content.replace(/^(?:\s*<at\b[^>]*(?:\/>|>\s*<\/at>))+\s*/i, "").replace(/^(?:\s*\[CQ:at,[^\]]+\])+\s*/i, "");
+}
+__name(stripLeadingBotMentions, "stripLeadingBotMentions");
+function getMessageCommandName(ctx, session) {
+  const strippedContent = session.stripped?.content?.trim();
+  const content = stripLeadingBotMentions(strippedContent ? session.stripped.content : session.content ?? "");
+  const firstWord = content.match(/^\s*(\S+)/)?.[1];
+  return firstWord ? normalizeCommandName(firstWord, getCommandPrefixes(ctx, session)) : null;
+}
+__name(getMessageCommandName, "getMessageCommandName");
+function apply6(ctx, config) {
+  if (config.permission.protectedCommands?.length > 0) {
+    const protectedSet = new Set(config.permission.protectedCommands.map((commandName) => normalizeCommandName(commandName)));
+    ctx.on("command/before-execute", async (argv) => {
+      const session = argv.session;
+      if (!session.guildId) return;
+      const commandNames = getCommandNames(argv.command);
+      if (!commandNames.some((commandName) => protectedSet.has(commandName))) return;
+      const hasPerm = await hasGuildPermission(session, config);
+      if (!hasPerm) {
+        return "权限不足，只有群管理员可以使用此指令。";
+      }
+    }, true);
+  }
+  if (!config.botSwitch?.enabled) return;
+  const cmdOpts = {};
+  if (config.permission.mode === "koishi") {
+    cmdOpts.authority = config.permission.koishiAuthority;
+  }
+  ctx.command("bot-on", "开启机器人", cmdOpts).action(async ({ session }) => {
+    if (!session.guildId) return "该指令只能在群聊中使用。";
+    if (config.permission.mode === "builtin") {
+      const hasPerm = await hasGuildPermission(session, config);
+      if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
+    }
+    await setGroupBotStatus(ctx, session.platform, session.guildId, true);
+    return "机器人已在此群开启。";
+  });
+  ctx.command("bot-off", "关闭机器人", cmdOpts).action(async ({ session }) => {
+    if (!session.guildId) return "该指令只能在群聊中使用。";
+    if (config.permission.mode === "builtin") {
+      const hasPerm = await hasGuildPermission(session, config);
+      if (!hasPerm) return "权限不足，只有群管理员可以使用此指令。";
+    }
+    await setGroupBotStatus(ctx, session.platform, session.guildId, false);
+    return "机器人已在此群关闭。所有指令和主动响应（入群欢迎、链接解析等）将被阻止。使用 bot-on 重新开启。";
+  });
+  ctx.on("command/before-execute", async (argv) => {
+    const session = argv.session;
+    if (!session.guildId) return;
+    if (isAdminCommand(argv.command)) {
+      return;
+    }
+    const status = await getGroupBotStatus(ctx, session.platform, session.guildId);
+    const isBotEnabled = status ? status.botEnabled : config.botSwitch.defaultState;
+    if (!isBotEnabled) {
+      const isMentioned = session.elements?.some((e) => e.type === "at" && e.attrs.id === session.bot.userId);
+      if (isMentioned && config.botSwitch.disabledMessage) {
+        try {
+          await session.send(config.botSwitch.disabledMessage);
+        } catch (e) {
+          ctx.logger("group-control-switch").warn("发送关闭提示失败", e);
+        }
+      }
+      return "";
+    }
+  }, true);
+  ctx.middleware(async (session, next) => {
+    if (!session.guildId) return next();
+    const status = await getGroupBotStatus(ctx, session.platform, session.guildId);
+    const isBotEnabled = status ? status.botEnabled : config.botSwitch.defaultState;
+    if (isBotEnabled) {
+      return next();
+    }
+    const commandName = session.argv?.command && isAdminCommand(session.argv.command) ? session.argv.command.name : getMessageCommandName(ctx, session);
+    if (commandName && ADMIN_COMMANDS.has(normalizeCommandName(commandName))) {
+      return next();
+    }
+    const isMentioned = session.elements?.some((e) => e.type === "at" && e.attrs.id === session.bot.userId);
+    if (isMentioned && config.botSwitch.disabledMessage) {
+      try {
+        await session.send(config.botSwitch.disabledMessage);
+      } catch (e) {
+      }
+    }
+    return;
+  }, true);
+}
+__name(apply6, "apply");
+
+// src/modules/friend.ts
+var friend_exports = {};
+__export(friend_exports, {
+  apply: () => apply7,
+  name: () => name7
+});
+var name7 = "group-control-friend";
+function getBotSelfId3(bot) {
+  return parseGuildId(String(bot?.selfId ?? bot?.userId ?? ""));
+}
+__name(getBotSelfId3, "getBotSelfId");
+function apply7(ctx, config) {
+  if (!config.friend.enabled) return;
+  ctx.setInterval(async () => {
+    const expireMs = config.friend.requestExpireDays * 24 * 60 * 60 * 1e3;
+    try {
+      for (const bot of ctx.bots) {
+        const selfId = getBotSelfId3(bot);
+        if (selfId) await clearExpiredPendingFriendRequests(ctx, bot.platform, selfId, expireMs);
+      }
+    } catch (e) {
+    }
+  }, 60 * 60 * 1e3);
+  ctx.on("friend-request", async (session) => {
+    const raw = session.original || session.raw || session.event?._data || {};
+    const flag = raw.flag || session.flag || session.messageId;
+    const userId = parseGuildId(raw.user_id ? String(raw.user_id) : session.userId);
+    const comment = raw.comment || session.comment || "";
+    const { platform } = session;
+    const selfId = getBotSelfId3(session.bot);
+    if (!userId || !selfId) {
+      ctx.logger("group-control-friend").warn(`无法解析好友申请 ID: userId=${raw.user_id ?? session.userId}, selfId=${session.bot?.selfId}`);
+      return;
+    }
+    let nickname = userId;
+    try {
+      const userNumber = toOneBotNumber(userId);
+      const info = userNumber == null ? null : await session.bot.internal?.getStrangerInfo?.(userNumber);
+      nickname = info?.nickname || nickname;
+    } catch (e) {
+    }
+    if (config.friend.autoApprove) {
+      try {
+        await session.bot.internal?.setFriendAddRequest?.(flag, true, "");
+        if (config.friend.notifyAdminOnApprove) {
+          const msg2 = config.friend.approveNotificationMessage.replaceAll("{userId}", userId).replaceAll("{nickname}", nickname).replaceAll("{comment}", comment);
+          await notifyAdmins(session.bot, config, msg2);
+        }
+      } catch (e) {
+        ctx.logger("group-control-friend").warn("自动通过好友申请失败", e);
+      }
+      return;
+    }
+    await addPendingFriendRequest(ctx, platform, selfId, { userId, nickname, comment, flag, time: Math.floor(Date.now() / 1e3) });
+    const msg = config.friend.requestMessage.replaceAll("{userId}", userId).replaceAll("{nickname}", nickname).replaceAll("{comment}", comment);
+    await notifyAdmins(session.bot, config, msg);
+  });
+  const cmdOpts = getAdminCommandOptions(config);
+  ctx.command("gc.friend-pending", "查看待处理的好友申请", cmdOpts).alias("gc.fp").action(async ({ session }) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足。";
+    const selfId = getBotSelfId3(session.bot);
+    if (!selfId) return "无法识别当前机器人账号，已取消操作。";
+    const all = await getAllPendingFriendRequests(ctx, session.platform, selfId);
+    if (all.length === 0) return "当前没有待处理的好友申请。";
+    const lines = ["待处理好友申请列表："];
+    for (const r of all) {
+      const elapsed = Math.floor((Date.now() / 1e3 - r.time) / 60);
+      lines.push(`- ${r.nickname}（${r.userId}）附言：${r.comment || "无"} · ${elapsed} 分钟前`);
+      lines.push(`  同意：gc.friend-approve ${r.userId} | 拒绝：gc.friend-reject ${r.userId}`);
+    }
+    return lines.join("\n");
+  });
+  ctx.command("gc.friend-approve <userId:string>", "同意好友申请", cmdOpts).alias("gc.fa").action(async ({ session }, userId) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足。";
+    if (!userId) return "请指定QQ号。用法：gc.friend-approve <QQ号>";
+    userId = parseGuildId(userId);
+    if (!userId) return "输入格式错误，请输入 QQ 号。";
+    const selfId = getBotSelfId3(session.bot);
+    if (!selfId) return "无法识别当前机器人账号，已取消操作。";
+    const record = await getPendingFriendRequest(ctx, session.platform, selfId, userId);
+    if (!record) return `未找到来自 ${userId} 的待处理好友申请。`;
+    try {
+      await session.bot.internal?.setFriendAddRequest?.(record.flag, true, "");
+      await removePendingFriendRequest(ctx, session.platform, selfId, userId);
+      return `已同意 ${record.nickname}（${userId}）的好友申请。`;
+    } catch (e) {
+      return `处理失败：${e.message}`;
+    }
+  });
+  ctx.command("gc.friend-reject <userId:string>", "拒绝好友申请", cmdOpts).alias("gc.fr").action(async ({ session }, userId) => {
+    if (!hasGlobalPermission(session, config)) return "权限不足。";
+    if (!userId) return "请指定QQ号。用法：gc.friend-reject <QQ号>";
+    userId = parseGuildId(userId);
+    if (!userId) return "输入格式错误，请输入 QQ 号。";
+    const selfId = getBotSelfId3(session.bot);
+    if (!selfId) return "无法识别当前机器人账号，已取消操作。";
+    const record = await getPendingFriendRequest(ctx, session.platform, selfId, userId);
+    if (!record) return `未找到来自 ${userId} 的待处理好友申请。`;
+    try {
+      await session.bot.internal?.setFriendAddRequest?.(record.flag, false, "");
+      await removePendingFriendRequest(ctx, session.platform, selfId, userId);
+      return `已拒绝 ${record.nickname}（${userId}）的好友申请。`;
+    } catch (e) {
+      return `处理失败：${e.message}`;
+    }
+  });
+}
+__name(apply7, "apply");
+
+// src/config.ts
+var import_koishi = require("koishi");
+var Config = import_koishi.Schema.intersect([
+  import_koishi.Schema.object({
+    admin: import_koishi.Schema.object({
+      adminQQs: import_koishi.Schema.array(String).default([]).description("管理员QQ号列表（权限验证及通知）"),
+      notificationGroupId: import_koishi.Schema.string().description("通知群号（填写后发到此群，否则私聊管理员）")
+    }).description("管理员配置")
+  }),
+  import_koishi.Schema.object({
+    permission: import_koishi.Schema.object({
+      mode: import_koishi.Schema.union([
+        import_koishi.Schema.const("koishi").description("使用 Koishi 自带权限系统 (authority)"),
+        import_koishi.Schema.const("builtin").description("使用插件内置权限管理 (群管理员/群主)")
+      ]).default("builtin").description("权限管理模式"),
+      koishiAuthority: import_koishi.Schema.natural().default(3).description("Koishi 模式下管理指令所需的最低权限等级"),
+      protectedCommands: import_koishi.Schema.array(String).default([]).description("需要群管理员权限才能使用的自定义指令名列表")
+    }).description("权限管理")
+  }),
+  import_koishi.Schema.object({
+    basic: import_koishi.Schema.object({
+      welcomeMessage: import_koishi.Schema.string().default("你好，我是机器人。").description("加入群聊时发送的欢迎消息"),
+      quitCommandEnabled: import_koishi.Schema.boolean().default(true).description("启用 quit 指令"),
+      quitMessage: import_koishi.Schema.string().default("收到来自{userId}的指令，即将退出群聊。").description("quit 指令触发后的群内提示，支持变量 {userId}"),
+      enableBlacklist: import_koishi.Schema.boolean().default(true).description("启用被踢出自动拉黑"),
+      blacklistMessage: import_koishi.Schema.string().role("textarea").default("此群聊已被拉黑，机器人将自动退出，请联系管理员移出黑名单。").description("被拉入黑名单群后的提示"),
+      notifyAdminOnKick: import_koishi.Schema.boolean().default(true).description("被踢出群时通知管理员"),
+      kickNotificationMessage: import_koishi.Schema.string().role("textarea").default("机器人已被踢出群聊\n群名称：{groupName}\n群号：{groupId}\n该群已被自动加入黑名单。").description("被踢出群通知模板，支持变量 {groupId}, {groupName}"),
+      smallGroupAutoQuit: import_koishi.Schema.boolean().default(false).description("启用小群自动退群"),
+      smallGroupThreshold: import_koishi.Schema.natural().default(30).description("小群人数阈值（低于等于此值时自动退群）"),
+      smallGroupCheckDelay: import_koishi.Schema.natural().default(3e3).description("加入后延迟检测时间（毫秒）"),
+      smallGroupExcludeOfficialBots: import_koishi.Schema.boolean().default(true).description("统计群人数时排除 QQ 官方机器人（is_robot）及机器人自身，仅统计真人成员"),
+      smallGroupRealtimeMonitor: import_koishi.Schema.boolean().default(true).description("实时监控群人数（监听成员退群事件，群缩小到阈值以下时自动退群）"),
+      smallGroupRecheckCooldown: import_koishi.Schema.natural().default(60).description("实时监控：同一群两次复检的最小间隔（秒），避免成员批量退群时频繁调用接口"),
+      smallGroupQuitMessage: import_koishi.Schema.string().role("textarea").default("该群人数过少（{memberCount}人），不满足最低人数要求（{threshold}人），机器人将自动退出。").description("小群退群提示，支持变量 {memberCount}, {threshold}, {groupName}, {groupId}"),
+      smallGroupNotifyAdmin: import_koishi.Schema.boolean().default(true).description("小群自动退群时通知管理员"),
+      smallGroupQualifiedNotifyAdmin: import_koishi.Schema.boolean().default(true).description("未经审核被拉入人数达标的群时通知管理员"),
+      smallGroupQualifiedMessage: import_koishi.Schema.string().role("textarea").default("机器人被未经审核地拉入群聊\n群名称：{groupName}\n群号：{groupId}\n当前人数：{memberCount}人（阈值：{threshold}人）\n请确认是否保留。").description("合格小群通知模板，支持变量 {groupName}, {groupId}, {memberCount}, {threshold}"),
+      notifyAdminOnMute: import_koishi.Schema.boolean().default(false).description("机器人被禁言时通知管理员"),
+      muteNotificationMessage: import_koishi.Schema.string().role("textarea").default("机器人在群聊中被禁言\n群名称：{groupName}\n群号：{groupId}\n操作者：{operatorId}\n禁言时长：{duration}秒").description("被禁言通知模板，支持变量 {groupId}, {groupName}, {operatorId}, {duration}"),
+      muteAutoQuit: import_koishi.Schema.boolean().default(false).description("机器人被禁言达到阈值时自动退群并拉黑"),
+      muteAutoQuitThreshold: import_koishi.Schema.natural().default(600).description("触发自动退群的禁言时长阈值（秒），被禁言时长 ≥ 此值即退群并拉黑"),
+      muteQuitNotificationMessage: import_koishi.Schema.string().role("textarea").default("机器人被长时间禁言，已自动退群并拉黑\n群名称：{groupName}\n群号：{groupId}\n操作者：{operatorId}\n禁言时长：{duration}秒").description("被禁言自动退群时发给管理员的通知模板，支持变量 {groupId}, {groupName}, {operatorId}, {duration}")
+    }).description("基础群组管理")
+  }),
+  import_koishi.Schema.object({
+    invite: import_koishi.Schema.object({
+      enabled: import_koishi.Schema.boolean().default(false).description("启用群聊邀请审核"),
+      autoApprove: import_koishi.Schema.boolean().default(false).description("自动同意邀请"),
+      notifyAdminOnApprove: import_koishi.Schema.boolean().default(true).description("自动同意时是否仍通知管理员"),
+      inviteWaitMessage: import_koishi.Schema.string().role("textarea").default("已收到您的群聊邀请，正在等待管理员审核，请耐心等待。").description("发给邀请者的等待提示"),
+      inviteApproveMessage: import_koishi.Schema.string().role("textarea").default("已自动通过您的群聊邀请，机器人正在加入群聊。").description("自动同意时发给邀请者的提示，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
+      inviteRequestMessage: import_koishi.Schema.string().role("textarea").default("收到新的群聊邀请请求：\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})\n\n请使用指令 gc.approve {groupId} 同意或 gc.reject {groupId} 拒绝。").description("发给管理员的请求消息模板，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
+      inviteApproveNotificationMessage: import_koishi.Schema.string().role("textarea").default("已自动通过群聊邀请\n群名称：{groupName}\n群号：{groupId}\n邀请者：{userName} (QQ: {userId})").description("自动同意时发给管理员的通知模板，支持变量 {groupName}, {groupId}, {userName}, {userId}"),
+      inviteExpireDays: import_koishi.Schema.natural().default(3).description("邀请记录过期天数"),
+      showDetailedLog: import_koishi.Schema.boolean().default(false).description("显示详细日志")
+    }).description("群聊邀请审核")
+  }),
+  import_koishi.Schema.object({
+    friend: import_koishi.Schema.object({
+      enabled: import_koishi.Schema.boolean().default(false).description("启用好友申请管理"),
+      autoApprove: import_koishi.Schema.boolean().default(false).description("自动通过好友申请（否则通知管理员手动处理）"),
+      notifyAdminOnApprove: import_koishi.Schema.boolean().default(true).description("自动通过时是否仍通知管理员"),
+      requestExpireDays: import_koishi.Schema.natural().default(7).description("待处理申请的过期天数"),
+      requestMessage: import_koishi.Schema.string().role("textarea").default("收到新的好友申请\nQQ：{userId}\n昵称：{nickname}\n附言：{comment}\n\n使用 gc.friend-approve {userId} 同意或 gc.friend-reject {userId} 拒绝。").description("通知管理员的消息模板，支持变量 {userId}, {nickname}, {comment}"),
+      approveNotificationMessage: import_koishi.Schema.string().role("textarea").default("已自动通过好友申请\nQQ：{userId}\n昵称：{nickname}\n附言：{comment}").description("自动通过时的通知模板，支持变量 {userId}, {nickname}, {comment}")
+    }).description("好友申请管理")
+  }),
+  import_koishi.Schema.object({
+    frequency: import_koishi.Schema.object({
+      enabled: import_koishi.Schema.boolean().default(false).description("启用群聊频率控制（指令及 @ 对话均受限）"),
+      limit: import_koishi.Schema.natural().default(5).description("群聊：时间窗口内允许的最大触发次数"),
+      window: import_koishi.Schema.natural().default(60).description("群聊：时间窗口（秒）"),
+      warnDelay: import_koishi.Schema.natural().default(30).description("群聊：警告后再次触发的时间阈值（秒），超出则进入屏蔽"),
+      blockDur: import_koishi.Schema.natural().default(300).description("群聊：首次屏蔽的基础时长（秒）"),
+      whitelist: import_koishi.Schema.array(String).default([]).description("群聊：不受频率限制的群号列表"),
+      privateEnabled: import_koishi.Schema.boolean().default(false).description("启用私聊频率控制"),
+      privateLimit: import_koishi.Schema.natural().default(10).description("私聊：时间窗口内允许的最大触发次数"),
+      privateWindow: import_koishi.Schema.natural().default(60).description("私聊：时间窗口（秒）"),
+      privateWarnDelay: import_koishi.Schema.natural().default(30).description("私聊：警告后再次触发的时间阈值（秒）"),
+      privateBlockDur: import_koishi.Schema.natural().default(300).description("私聊：首次屏蔽的基础时长（秒）"),
+      privateWhitelist: import_koishi.Schema.array(String).default([]).description("私聊：不受频率限制的用户ID列表"),
+      blockExpBase: import_koishi.Schema.natural().min(1).default(2).description("屏蔽时长指数增长底数（时长 = blockDur × base^(次数-1)），设为 1 禁用"),
+      blockExpWindow: import_koishi.Schema.natural().default(3600).description("指数增长重置窗口（秒），从最后一次屏蔽结束计算，超出则重置次数"),
+      blockNotifyCooldown: import_koishi.Schema.natural().default(60).description("屏蔽期间提示消息的冷却时间（秒），避免刷屏"),
+      warnMsg: import_koishi.Schema.string().default("发言频率过高，请慢一点~").description("首次超限警告消息"),
+      blockMsg: import_koishi.Schema.string().default("发言频率过高，已被禁用 {duration} 秒。").description("进入屏蔽时的通知，支持变量 {duration}"),
+      blockedMsg: import_koishi.Schema.string().default("暂时被禁用，还有 {time} 秒解禁。").description("屏蔽期间再次触发时的提示，支持变量 {time}")
+    }).description("频率控制")
+  }),
+  import_koishi.Schema.object({
+    botSwitch: import_koishi.Schema.object({
+      enabled: import_koishi.Schema.boolean().default(true).description("启用群聊 bot 开关"),
+      defaultState: import_koishi.Schema.boolean().default(true).description("默认开启状态"),
+      disabledMessage: import_koishi.Schema.string().role("textarea").default("机器人当前在此群处于关闭状态，请使用 bot-on 开启。").description("关闭状态下被 @ 时的提示")
+    }).description("机器人开关控制")
+  })
+]);
+
+// src/index.ts
+var name8 = "group-control";
+var inject = ["database"];
+function apply8(ctx, config) {
+  ctx.on("dispose", () => {
+    clearGuildAdminCache();
+  });
+  ctx.plugin(database_exports);
+  ctx.plugin(basic_exports, config);
+  ctx.plugin(invite_exports, config);
+  ctx.plugin(frequency_exports, config);
+  ctx.plugin(commands_exports, config);
+  ctx.plugin(switch_exports, config);
+  ctx.plugin(friend_exports, config);
+}
+__name(apply8, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});