koishi-plugin-qxgl-satori 0.0.4 → 0.0.5

package/lib/index.js

@@ -4,6 +4,7 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 
 // src/index.ts
 Object.defineProperty(exports, "__esModule", { value: true });
+var koishi = require("koishi");
 var { Schema, Logger, h } = require("koishi");
 var logger = new Logger("qxgl-satori");
 var inject = ["database"];
@@ -13,110 +14,92 @@ var fsSync = require("node:fs");
 var path = require("node:path");
 var { pathToFileURL } = require("node:url");
 var Config = Schema.intersect([
+  // 板块 1：授权核心系统
   Schema.object({
-    authorizationMode: Schema.union([
-      Schema.const("disabled").description("关闭 - 所有群可用，仅记录不拦截"),
-      Schema.const("record").description("记录 - 新群自动创建未授权记录，不阻断"),
-      Schema.const("strict").description("严格 - 未授权/过期自动拦截消息")
-    ]).default("strict").description("授权系统模式"),
-    autoLeaveOnExpiry: Schema.boolean().default(false).description("严格模式下，授权到期是否自动退群"),
-    autoLeaveOnMute: Schema.boolean().default(false).description("被禁言时是否自动退群（Satori适配器需支持）"),
-    expiryReminderDays: Schema.tuple([Number, Number]).default([3, 1]).description("到期前提醒天数（默认3天和1天前）")
-  }).description("授权系统控制"),
+    enableAuthSystem: Schema.boolean().default(true).description("开启授权系统<br>`关闭时所有群均可使用问答功能`<br>`开启时新群自动记录为未授权，但授权指令始终可用`"),
+    autoLeaveOnExpiry: Schema.boolean().default(false).description("授权到期时是否自动退群（Satori: 尝试调用 leaveGuild）"),
+    autoLeaveOnMute: Schema.boolean().default(false).description("被禁言时是否自动退群"),
+    defaultExpiry: Schema.string().default("2099-12-31").description("默认到期时间（用于显示，格式：YYYY-MM-DD）")
+  }).description("授权管理系统"),
+  // 板块 2：存储与图片设置（Satori 专用）
   Schema.object({
-    commandAuthority: Schema.number().default(3).description("管理类指令所需权限等级"),
-    adminList: Schema.array(Schema.object({
-      adminId: Schema.string().description("管理员用户ID"),
-      allowedCommands: Schema.array(Schema.union([
-        "群授权",
-        "私聊授权",
-        "到期时间",
-        "查询到期",
-        "全局延期",
-        "全局减少",
-        "取消授权",
-        "更换授权",
-        "更新名称",
-        "列出已记录群",
-        "备份数据",
-        "添加",
-        "删除",
-        "全局添加",
-        "全局删除",
-        "查找关键词",
-        "修改",
-        "全局修改",
-        "查看关键词列表",
-        "测试授权",
-        "取消测试授权",
-        "测试同步",
-        "测试发布",
-        "测试添加",
-        "测试删除",
-        "测试修改"
-      ])).default(["到期时间"]).description("允许使用的指令")
-    })).role("table").description("管理员列表（ID填0代表所有用户）").default([{ adminId: "0", allowedCommands: ["到期时间"] }]),
-    channelAdminAuth: Schema.boolean().default(false).description("开启后自动允许群管理员/群主使用所有指令（需适配器支持角色获取）")
-  }).description("权限设置"),
+    storageName: Schema.string().default("qxgl-satori").description("数据文件夹名称（位于 data/ 下）"),
+    imageMode: Schema.union([
+      Schema.const("file").description("本地文件（推荐）：保存为文件，使用 file:/// 协议发送（Satori 原生支持）")
+    ]).default("file").description("图片发送模式<br>Satori 适配器仅支持本地文件模式"),
+    autoRecordChannel: Schema.boolean().default(true).description("自动记录群聊<br>`开启后，新群首次消息自动创建未授权记录（需 enableAuthSystem 为 true）`")
+  }).description("存储设置"),
+  // 板块 3：指令名称本土化（可自定义，但默认中文）
+  Schema.object({
+    commandGroupAuth: Schema.string().default("群授权").description("群授权指令名称"),
+    commandPrivateAuth: Schema.string().default("私聊授权").description("私聊授权指令名称"),
+    commandCancelAuth: Schema.string().default("取消授权").description("取消授权指令名称"),
+    commandChangeAuth: Schema.string().default("更换授权").description("更换授权指令名称"),
+    commandQueryExpiry: Schema.string().default("到期时间").description("查询本群到期时间指令名称"),
+    commandQueryTargetExpiry: Schema.string().default("查询到期").description("查询指定目标到期时间指令名称"),
+    commandGlobalDelay: Schema.string().default("全局延期").description("全局延期指令名称"),
+    commandGlobalReduce: Schema.string().default("全局减少").description("全局减少指令名称"),
+    commandUpdateName: Schema.string().default("更新名称").description("更新群名称指令名称"),
+    commandListChannels: Schema.string().default("列出已记录群").description("列出所有已记录群指令名称"),
+    commandAddKeyword: Schema.string().default("添加").description("添加关键词指令名称"),
+    commandDeleteKeyword: Schema.string().default("删除").description("删除关键词指令名称"),
+    commandGlobalAddKeyword: Schema.string().default("全局添加").description("全局添加关键词指令名称"),
+    commandGlobalDeleteKeyword: Schema.string().default("全局删除").description("全局删除关键词指令名称"),
+    commandViewKeywords: Schema.string().default("查看关键词列表").description("查看关键词列表指令名称"),
+    commandSearchKeyword: Schema.string().default("查找关键词").description("查找关键词指令名称"),
+    commandFixKeyword: Schema.string().default("修改").description("修改关键词指令名称"),
+    commandGlobalFixKeyword: Schema.string().default("全局修改").description("全局修改关键词指令名称"),
+    commandTestAuth: Schema.string().default("测试授权").description("测试授权指令名称"),
+    commandCancelTestAuth: Schema.string().default("取消测试授权").description("取消测试授权指令名称"),
+    commandTestSync: Schema.string().default("测试同步").description("测试同步指令名称"),
+    commandTestPublish: Schema.string().default("测试发布").description("测试发布指令名称"),
+    commandTestAdd: Schema.string().default("测试添加").description("测试添加指令名称"),
+    commandTestDelete: Schema.string().default("测试删除").description("测试删除指令名称"),
+    commandTestFix: Schema.string().default("测试修改").description("测试修改指令名称"),
+    commandBackup: Schema.string().default("备份到").description("备份指令名称")
+  }).description("指令名称设置"),
+  // 板块 4：权限管理
   Schema.object({
-    triggerPrefix: Schema.string().default("添加").description("触发添加关键词的指令前缀"),
-    deletePrefix: Schema.string().default("删除").description("触发删除的指令前缀"),
-    cancelKeyword: Schema.string().default("取消添加").description("取消添加流程的关键词"),
-    endKeyword: Schema.string().default("结束添加").description("结束添加流程的关键词"),
-    globalTriggerPrefix: Schema.string().default("全局添加").description("全局添加指令前缀"),
-    globalDeletePrefix: Schema.string().default("全局删除").description("全局删除指令前缀"),
-    viewListCommand: Schema.string().default("查看关键词列表").description("查看列表指令"),
-    searchCommand: Schema.string().default("查找关键词").description("搜索指令"),
-    fixCommand: Schema.string().default("修改").description("修改指令"),
-    globalFixCommand: Schema.string().default("全局修改").description("全局修改指令"),
-    addTimeout: Schema.number().role("slider").min(1).max(30).step(1).default(5).description("添加回复输入时限（分钟）"),
-    defaultImageExt: Schema.union(["jpg", "png", "gif"]).default("png").description("保存图片默认后缀"),
-    imageSendMode: Schema.union([
-      Schema.const("file").description("本地文件路径（转换为file://URL）"),
-      Schema.const("base64").description("Base64 DataURI（兼容性最好）")
-    ]).default("file").description("图片发送方式"),
-    localPathMapping: Schema.string().default("").description("本地路径映射（如Docker内外路径映射，格式：/host/path:/container/path，可选）")
-  }).description("关键词指令设置"),
+    commandAuthority: Schema.number().default(3).description("允许使用管理指令的最低权限等级"),
+    adminList: Schema.array(Schema.object({
+      adminID: Schema.string().description("管理员用户ID（0 代表所有用户）"),
+      allowedCommands: Schema.array(Schema.string()).default([]).description("允许使用的指令名称（空数组代表允许所有）")
+    })).role("table").description("管理员列表<br>`adminID 为 0 表示默认权限`").default([{ "adminID": "0", "allowedCommands": [] }]),
+    channelAdminAuth: Schema.boolean().default(false).description("开启后自动允许群主/管理员使用授权指令<br>`须确保适配器支持获取群员角色`")
+  }).description("权限管理"),
+  // 板块 5：关键词匹配与响应
   Schema.object({
-    matchPrefixes: Schema.array(String).role("table").default(["", "/", "#"]).description("关键词匹配前缀配置"),
-    treatAsLowercase: Schema.boolean().default(true).description("英文关键词匹配时忽略大小写"),
-    deleteBranchOnly: Schema.boolean().default(true).description("多段回复删除时必须指定序号（-q参数），防止误删"),
-    handleDuplicate: Schema.union([
-      Schema.const("replace").description("直接覆盖"),
-      Schema.const("append").description("添加并列回复（随机选择）"),
-      Schema.const("reject").description("拒绝添加，提示已存在")
-    ]).default("append").description("重复关键词处理方式"),
-    alwaysPrompt: Schema.union([
-      Schema.const("never").description("不返回提示（仅首次）"),
-      Schema.const("once").description("仅首次提示"),
-      Schema.const("always").description("每次输入都提示")
-    ]).default("once").description("添加流程提示频率"),
-    multisegmentMode: Schema.union([
-      Schema.const("1").description("多段独立发送（逐条）"),
-      Schema.const("2").description("合并为图文消息（单次发送）"),
-      Schema.const("3").description("合并转发（需适配器支持）"),
-      Schema.const("4").description("原格式合并转发")
-    ]).default("2").description("多段回复发送方式"),
-    frequencyLimit: Schema.number().default(0).description("同一问答最小触发间隔（秒，0为不限制）"),
-    frequencyScope: Schema.union([
-      Schema.const("global").description("全局限制"),
-      Schema.const("channel").description("按频道独立限制")
-    ]).default("channel").description("频率限制范围"),
+    prefix: Schema.array(String).role("table").default(["", "/", "#"]).description("指令前缀（用于关键词匹配）"),
+    treatAllAsLowercase: Schema.boolean().default(true).description("英文关键词匹配忽略大小写"),
+    deleteBranchOnly: Schema.boolean().default(true).description("删除多段回复时必须指定序号"),
+    addKeywordTime: Schema.number().role("slider").min(1).max(30).step(1).default(5).description("添加回复的输入时限（分钟）"),
+    matchPatternForExit: Schema.union([
+      Schema.const("1").description("仅接受一次性输入"),
+      Schema.const("2").description('完全匹配"结束添加"时退出'),
+      Schema.const("3").description('包含"结束添加"时退出'),
+      Schema.const("4").description("完全匹配或包含均可退出")
+    ]).role("radio").default("4").description("多段添加退出方式"),
+    keywordOfEsc: Schema.string().default("取消添加").description("取消添加的关键词"),
+    keywordOfEnd: Schema.string().default("结束添加").description("结束多段添加的关键词"),
+    prompt: Schema.string().role("textarea", { rows: [2, 4] }).default("请输入回复内容（输入 取消添加 以取消，输入 结束添加 以结束）：").description("添加时的文字提示"),
+    frequencyLimitation: Schema.number().default(0).description("同一问答的最小触发间隔（秒，0 为无限制）"),
+    restrictionType: Schema.union([
+      Schema.const("1").description("对同一个问题（全部对象）"),
+      Schema.const("2").description("仅对同一个频道（不同频道独立计数）")
+    ]).role("radio").default("2").description("频率限制对象"),
     searchRange: Schema.union([
-      Schema.const("local").description("仅当前频道"),
-      Schema.const("all").description("全部频道"),
-      Schema.const("mixed").description("当前频道+全局")
-    ]).default("mixed").description("查看/搜索的范围"),
-    viewListMode: Schema.union([
-      Schema.const("text").description("文字列表"),
-      Schema.const("image").description("图片列表（需puppeteer）")
-    ]).default("text").description("查看列表返回格式")
-  }).description("问答行为设置"),
+      Schema.const("1").description("仅在当前频道搜索"),
+      Schema.const("2").description("搜索全部频道的问答"),
+      Schema.const("3").description("当前频道 + 全局问答")
+    ]).role("radio").default("3").description("关键词搜索范围"),
+    defaultImageExtension: Schema.union(["jpg", "png", "gif"]).default("png").description("保存图片的后缀名"),
+    unifiedAtField: Schema.boolean().default(false).description('统一 at 消息格式为 <at id="123"/>'),
+    loggerInfo: Schema.boolean().default(false).description("日志调试模式")
+  }).description("关键词问答设置"),
+  // 板块 6：测试环境
   Schema.object({
-    enableTestEnv: Schema.boolean().default(true).description("启用测试环境功能"),
-    unifiedAtField: Schema.boolean().default(true).description('统一at消息格式为<at id="xxx"/>（移除name属性防不一致）'),
-    debugMode: Schema.boolean().default(false).description("调试日志模式")
-  }).description("高级设置")
+    testChannels: Schema.array(Schema.string()).default([]).description("测试频道列表<br>`格式: 平台:频道ID，如 satori:12345 或 private:67890`")
+  }).description("测试环境设置")
 ]);
 var usage = `
 <!DOCTYPE html>
@@ -125,997 +108,1023 @@ var usage = `
 <meta charset="UTF-8">
 <title>qxgl-satori 插件使用说明</title>
 <style>
-body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; line-height: 1.6; max-width: 900px; margin: 0 auto; padding: 20px; color: #333; }
-h1 { color: #2c3e50; border-bottom: 3px solid #3498db; padding-bottom: 10px; }
-h2 { color: #34495e; margin-top: 30px; border-left: 5px solid #3498db; padding-left: 15px; }
-h3 { color: #7f8c8d; }
+body { font-family: system-ui, sans-serif; line-height: 1.6; max-width: 800px; margin: 0 auto; padding: 20px; }
+h1 { color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }
+h2 { color: #34495e; margin-top: 24px; }
+code { background: #f4f4f4; padding: 2px 6px; border-radius: 3px; font-family: monospace; }
 ul { padding-left: 20px; }
 li { margin: 8px 0; }
-code { background: #f4f4f4; padding: 2px 6px; border-radius: 3px; font-family: Consolas, monospace; color: #e74c3c; }
-.detail { background: #ecf0f1; padding: 15px; border-radius: 8px; margin: 10px 0; }
+.notice { background: #fff3cd; border-left: 4px solid #ffc107; padding: 12px; margin: 16px 0; }
 </style>
 </head>
 <body>
-<h1>qxgl-satori 插件使用说明</h1>
-<p>专为 Satori 适配器优化的群管与问答一体化插件，支持多账号共享授权数据。</p>
+<h1>qxgl-satori 插件</h1>
+<p>基于 Satori 协议优化的群管与问答系统，支持多账号共享数据库。</p>
 
-<h2>一、授权管理系统（指令永不过期）</h2>
-<div class="detail">
-<p><strong>核心特性</strong>：所有授权管理指令不受授权状态影响，即使被拉黑或已过期仍可正常使用。</p>
+<div class="notice">
+<strong>多账号兼容：</strong>本插件通过 platform + channelId 作为主键，不绑定任何 Bot 账号（selfId），支持多个 Bot 实例共享同一数据库管理相同群聊。
+</div>
+
+<h2>授权管理系统</h2>
 <ul>
-  <li><code>群授权 &lt;群号&gt; &lt;±月数&gt; [授权人]</code> - 授权群聊，+6为增6月，-6为减6月</li>
-  <li><code>私聊授权 &lt;用户ID&gt; &lt;±月数&gt; [授权人]</code> - 授权私聊</li>
-  <li><code>取消授权 &lt;目标ID&gt;</code> - 删除授权记录</li>
-  <li><code>更换授权 &lt;原ID&gt; &lt;新ID&gt;</code> - 迁移授权数据</li>
-  <li><code>到期时间</code> - 查询当前上下文到期时间</li>
-  <li><code>查询到期 &lt;目标ID&gt;</code> - 查询指定目标</li>
-  <li><code>全局延期 &lt;天数&gt;</code> / <code>全局减少 &lt;天数&gt;</code> - 批量调整所有授权</li>
-  <li><code>更新名称</code> - 手动刷新群名缓存</li>
-  <li><code>列出已记录群</code> - 查看所有群授权状态</li>
-  <li><code>备份数据</code> - 导出数据库为JSON</li>
+<li><strong>群授权</strong>：<code>群授权 &lt;群号&gt; &lt;±月数&gt; [授权人]</code> - 增加或减少群组授权时长</li>
+<li><strong>私聊授权</strong>：<code>私聊授权 &lt;用户ID&gt; &lt;±月数&gt; [授权人]</code></li>
+<li><strong>更换授权</strong>：<code>更换授权 &lt;原群号&gt; &lt;新群号&gt;</code> - 迁移授权记录</li>
+<li><strong>取消授权</strong>：<code>取消授权 &lt;群号或用户ID&gt;</code></li>
+<li><strong>到期时间</strong>：<code>到期时间</code> - 查询当前群/私聊授权状态</li>
+<li><strong>查询到期</strong>：<code>查询到期 &lt;目标ID&gt;</code> - 查询指定目标</li>
+<li><strong>全局延期/减少</strong>：<code>全局延期 &lt;天数&gt;</code> / <code>全局减少 &lt;天数&gt;</code></li>
+<li><strong>更新名称</strong>：<code>更新名称</code> - 手动刷新群名缓存</li>
+<li><strong>列出已记录群</strong>：<code>列出已记录群</code> - 查看所有授权记录</li>
 </ul>
-</div>
 
-<h2>二、关键词问答系统（Satori专精）</h2>
-<div class="detail">
+<h2>关键词问答系统</h2>
 <ul>
-  <li><code>添加 [关键词] [-x] [-f方式]</code> - 添加关键词，-x为正则，-f指定发送方式(1-4)</li>
-  <li><code>全局添加 [关键词] [-x] [-f方式]</code> - 添加全局关键词</li>
-  <li><code>删除 [关键词] [-q序号]</code> / <code>全局删除 [关键词] [-q序号]</code> - 删除指定或全部回复</li>
-  <li><code>修改 [关键词] [-q序号]</code> / <code>全局修改 [关键词] [-q序号]</code> - 修改指定回复</li>
-  <li><code>查找关键词 [关键词]</code> - 模糊搜索</li>
-  <li><code>查看关键词列表</code> - 列出当前范围所有关键词</li>
+<li><strong>添加</strong>：<code>添加 [关键词]</code> - 支持多段输入（图片自动保存为本地文件）</li>
+<li><strong>全局添加</strong>：<code>全局添加 [关键词]</code></li>
+<li><strong>删除</strong>：<code>删除 [关键词] [-q &lt;序号&gt;]</code></li>
+<li><strong>修改</strong>：<code>修改 [关键词] [-q &lt;序号&gt;]</code></li>
+<li><strong>查找</strong>：<code>查找关键词 [关键词]</code></li>
+<li><strong>查看列表</strong>：<code>查看关键词列表</code></li>
 </ul>
-<p>支持变量：<code>{expiryDate}</code> <code>{authorizer}</code> <code>{channelId}</code> <code>{updateDate}</code></p>
-</div>
 
-<h2>三、测试环境管理</h2>
-<div class="detail">
+<h2>测试环境</h2>
 <ul>
-  <li><code>测试授权 &lt;ID1&gt; [ID2...]</code> - 将群/用户加入测试名单</li>
-  <li><code>取消测试授权 &lt;ID...&gt;</code> - 移出测试名单</li>
-  <li><code>测试同步</code> - 将正式数据复制到测试环境（覆盖）</li>
-  <li><code>测试发布</code>（别名：<code>测试转正</code>）- 将测试数据发布到正式（自动备份）</li>
-  <li><code>测试添加/测试删除/测试修改</code> - 独立的测试问答操作</li>
+<li><strong>测试授权</strong>：<code>测试授权 &lt;群号/用户ID&gt;</code> - 将频道加入测试名单（仅响应测试问答）</li>
+<li><strong>测试同步</strong>：<code>测试同步</code> - 将全局问答复制到测试环境</li>
+<li><strong>测试发布</strong>：<code>测试发布</code> - 将测试问答发布到全局（自动备份）</li>
 </ul>
-<p><strong>注意</strong>：测试名单内的群仅响应测试数据，与正式环境完全隔离。</p>
-</div>
 
-<h2>四、多账号共享说明</h2>
-<div class="detail">
-<p>本插件使用 <code>platform</code> + <code>channelId</code> 作为主键，<strong>不区分 Bot 账号</strong>。</p>
-<p>同一平台（如 Satori）下的多个 Bot 账号共用同一套授权数据，更换 Bot 账号无需重新授权。</p>
-</div>
+<h2>Satori 特性</h2>
+<ul>
+<li>图片统一使用 <code>file:///</code> 协议本地路径，确保长期可用</li>
+<li>多账号共享授权数据，更换 Bot 账号无需重新授权</li>
+<li>授权指令在任何状态下（包括未授权群）始终可用，防止死锁</li>
+</ul>
 </body>
 </html>
 `;
+function formatDate(date) {
+  if (!date) return "未设置";
+  const d = new Date(date);
+  const year = d.getFullYear();
+  const month = (d.getMonth() + 1).toString().padStart(2, "0");
+  const day = d.getDate().toString().padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+__name(formatDate, "formatDate");
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function unescapeHtml(str) {
+  const map = { "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"', "&#039;": "'" };
+  return str.replace(/&amp;|&lt;|&gt;|&quot;|&#039;/g, (m) => map[m]);
+}
+__name(unescapeHtml, "unescapeHtml");
 async function apply(ctx, config) {
-  const dataDir = path.join(ctx.baseDir, "data", "qxgl-satori");
-  const imagesDir = path.join(dataDir, "images");
-  if (!fsSync.existsSync(dataDir)) {
-    fsSync.mkdirSync(dataDir, { recursive: true });
-  }
-  if (!fsSync.existsSync(imagesDir)) {
-    fsSync.mkdirSync(imagesDir, { recursive: true });
-  }
-  const testFilePath = path.join(dataDir, "test.json");
-  if (!fsSync.existsSync(testFilePath)) {
-    fsSync.writeFileSync(testFilePath, "{}");
-  }
+  const root = path.join(ctx.baseDir, "data", config.storageName);
+  const imageRoot = path.join(root, "images");
+  if (!fsSync.existsSync(root)) fsSync.mkdirSync(root, { recursive: true });
+  if (!fsSync.existsSync(imageRoot)) fsSync.mkdirSync(imageRoot, { recursive: true });
+  const globalFile = path.join(root, "global.json");
+  const testFile = path.join(root, "test.json");
+  if (!fsSync.existsSync(globalFile)) fsSync.writeFileSync(globalFile, "{}");
+  if (!fsSync.existsSync(testFile)) fsSync.writeFileSync(testFile, "{}");
   let lastTriggerTimes = {};
   function logInfo(message) {
-    if (config.debugMode) {
-      logger.info(message);
-    }
+    if (config.loggerInfo) logger.info(message);
   }
   __name(logInfo, "logInfo");
   ctx.model.extend("qxgl_satori_auth", {
     platform: "string",
     channelId: "string",
+    isAuthorized: "boolean",
+    // true/false，替代原 isblockedchannel
     expiryDate: "date",
     authorizer: "string",
     channelName: "string",
-    updateDate: "date",
-    isBlocked: "boolean",
-    testChannels: "list"
+    recordDate: "date",
+    updateDate: "date"
   }, {
     primary: ["platform", "channelId"]
+    // 复合主键，确保多账号共享同一记录
   });
-  function hasPermission(session, command) {
+  function isAdmin(session) {
+    const roles = session.event?.member?.roles || [];
+    return roles.includes("admin") || roles.includes("owner");
+  }
+  __name(isAdmin, "isAdmin");
+  function hasPermission(session, commandName) {
     const userId = session.userId;
-    const adminConfig = config.adminList.find((a) => a.adminId === userId);
-    const defaultConfig = config.adminList.find((a) => a.adminId === "0");
-    if (defaultConfig?.allowedCommands.includes(command)) return true;
-    if (adminConfig?.allowedCommands.includes(command)) return true;
-    if (config.channelAdminAuth) {
-      const roles = session.event?.member?.roles || [];
-      if (roles.includes("admin") || roles.includes("owner")) {
-        if (!adminConfig) return true;
-        return adminConfig.allowedCommands.includes(command);
-      }
+    const adminConfig = config.adminList.find((a) => a.adminID === userId);
+    const defaultConfig = config.adminList.find((a) => a.adminID === "0");
+    if (defaultConfig && (defaultConfig.allowedCommands.length === 0 || defaultConfig.allowedCommands.includes(commandName))) {
+      return true;
     }
-    return false;
-  }
-  __name(hasPermission, "hasPermission");
-  async function ensureChannelRecorded(session) {
-    const { platform, channelId } = session;
-    if (!channelId || channelId.startsWith("private:")) return;
-    const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
-    if (record.length === 0 && config.authorizationMode !== "disabled") {
-      let channelName = "未知群聊";
-      try {
-        if (session.bot?.getGuild) {
-          const guild = await session.bot.getGuild(channelId);
-          channelName = guild?.name || channelName;
-        }
-      } catch (e) {
-        logger.warn(`获取群名失败 ${channelId}: ${e.message}`);
-      }
-      await ctx.database.create("qxgl_satori_auth", {
-        platform,
-        channelId,
-        expiryDate: null,
-        isBlocked: false,
-        authorizer: "系统",
-        channelName,
-        updateDate: /* @__PURE__ */ new Date(),
-        testChannels: []
-      });
-      logInfo(`自动记录群 ${channelId}`);
+    if (adminConfig) {
+      return adminConfig.allowedCommands.length === 0 || adminConfig.allowedCommands.includes(commandName);
     }
-  }
-  __name(ensureChannelRecorded, "ensureChannelRecorded");
-  async function isAuthorized(session) {
-    if (config.authorizationMode === "disabled") return true;
-    const { platform, channelId } = session;
-    const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
-    if (record.length === 0) {
-      if (config.authorizationMode === "strict") return false;
+    if (config.channelAdminAuth && isAdmin(session)) {
       return true;
     }
-    const auth = record[0];
-    if (auth.isBlocked) return false;
-    if (!auth.expiryDate) return true;
-    return (/* @__PURE__ */ new Date()).getTime() <= new Date(auth.expiryDate).getTime();
+    return false;
   }
-  __name(isAuthorized, "isAuthorized");
-  async function checkAndUpdateExpiry(session) {
-    const { platform, channelId } = session;
-    const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
-    if (record.length === 0) return;
-    const auth = record[0];
-    if (!auth.expiryDate) return;
-    const daysUntil = Math.floor((new Date(auth.expiryDate).getTime() - (/* @__PURE__ */ new Date()).getTime()) / (1e3 * 60 * 60 * 24));
-    const [remind3, remind1] = config.expiryReminderDays;
-    if (daysUntil === remind3 || daysUntil === remind1) {
-      await session.send(`⚠️ 授权提醒：本群授权将于 ${formatDate(auth.expiryDate)} 到期（剩${daysUntil}天）
-授权人：${auth.authorizer || "未知"}`);
+  __name(hasPermission, "hasPermission");
+  function isAuthCommand(content) {
+    if (!content) return false;
+    const trimmed = content.trim();
+    const authCommands = [
+      config.commandGroupAuth,
+      config.commandPrivateAuth,
+      config.commandCancelAuth,
+      config.commandChangeAuth,
+      config.commandQueryExpiry,
+      config.commandQueryTargetExpiry,
+      config.commandGlobalDelay,
+      config.commandGlobalReduce,
+      config.commandUpdateName,
+      config.commandListChannels,
+      config.commandBackup
+    ];
+    for (const prefix of config.prefix) {
+      for (const cmd of authCommands) {
+        if (trimmed.startsWith(prefix + cmd)) return true;
+      }
     }
+    return false;
   }
-  __name(checkAndUpdateExpiry, "checkAndUpdateExpiry");
-  function getFilePath(channelId, isGlobal = false) {
-    if (isGlobal) return path.join(dataDir, "global.json");
-    return path.join(dataDir, `${channelId}.json`);
+  __name(isAuthCommand, "isAuthCommand");
+  function getChannelFile(platform, channelId) {
+    return path.join(root, `${platform}_${channelId}.json`);
   }
-  __name(getFilePath, "getFilePath");
-  async function downloadImage(url, scope = "global") {
+  __name(getChannelFile, "getChannelFile");
+  async function downloadImage(url, channelId, isGlobal = false, isTest = false) {
     try {
+      const subDir = isGlobal ? "global" : isTest ? "test" : channelId.replace(/:/g, "_");
+      const fullDir = path.join(imageRoot, subDir);
+      await fs.mkdir(fullDir, { recursive: true });
       const buffer = await ctx.http.get(url, { responseType: "arraybuffer" }).then((r) => Buffer.from(r));
-      const folder = path.join(imagesDir, scope);
-      if (!fsSync.existsSync(folder)) {
-        fsSync.mkdirSync(folder, { recursive: true });
-      }
-      const ext = (url.match(/\.(\w+)(?:\?|$)/)?.[1] || config.defaultImageExt).toLowerCase();
-      const fileName = `${Date.now()}_${Math.random().toString(36).slice(2)}.${ext}`;
-      const filePath = path.join(folder, fileName);
-      await fs.writeFile(filePath, buffer);
-      return { filePath, buffer };
-    } catch (e) {
-      logger.error(`下载图片失败: ${e.message}`);
-      throw new Error("图片下载失败");
+      const ext = path.extname(new URL(url).pathname) || `.${config.defaultImageExtension}`;
+      const fileName = `${Date.now()}${ext}`;
+      const localPath = path.join(fullDir, fileName);
+      await fs.writeFile(localPath, buffer);
+      return pathToFileURL(localPath).href;
+    } catch (error) {
+      logger.error(`[qxgl-satori] 下载图片失败: ${error.message}`);
+      throw new Error(`图片下载失败: ${error.message}`);
     }
   }
   __name(downloadImage, "downloadImage");
-  function resolveImagePath(filePath) {
-    if (config.localPathMapping) {
-      const [host, container] = config.localPathMapping.split(":");
-      if (host && container && filePath.startsWith(host)) {
-        filePath = filePath.replace(host, container);
-      }
-    }
-    return filePath;
-  }
-  __name(resolveImagePath, "resolveImagePath");
-  async function formatImageReply(imagePathOrData) {
-    if (config.imageSendMode === "base64") {
-      let buffer;
-      if (imagePathOrData.startsWith("data:")) {
-        return h.image(imagePathOrData);
-      } else if (imagePathOrData.startsWith("http")) {
-        const result = await downloadImage(imagePathOrData);
-        buffer = result.buffer;
-      } else {
-        const realPath = resolveImagePath(imagePathOrData);
-        buffer = await fs.readFile(realPath);
-      }
-      const base64 = buffer.toString("base64");
-      return h.image(`data:image/png;base64,${base64}`);
-    } else {
-      if (imagePathOrData.startsWith("http")) {
-        const { filePath } = await downloadImage(imagePathOrData);
-        const realPath = resolveImagePath(filePath);
-        return h.image(pathToFileURL(realPath).href);
-      } else {
-        const realPath = resolveImagePath(imagePathOrData);
-        if (!fsSync.existsSync(realPath)) {
-          return h.text("[图片文件丢失]");
-        }
-        return h.image(pathToFileURL(realPath).href);
-      }
-    }
-  }
-  __name(formatImageReply, "formatImageReply");
-  async function parseReplyContent(replyContent, scope = "global") {
-    const elements = h.parse(replyContent);
+  async function parseReplyContent(reply, channelId, isGlobal = false, isTest = false) {
+    const elements = h.parse(reply);
     const results = [];
     for (const el of elements) {
       if (el.type === "img" || el.type === "image") {
-        try {
-          const { filePath } = await downloadImage(el.attrs.src, scope);
-          results.push({
-            type: "image",
-            content: filePath,
-            replyMode: config.multisegmentMode
-          });
-        } catch (e) {
-          results.push({ type: "text", content: `[图片下载失败]`, replyMode: config.multisegmentMode });
-        }
+        const localUrl = await downloadImage(el.attrs.src, channelId, isGlobal, isTest);
+        results.push({ type: "image", text: localUrl });
       } else if (el.type === "text") {
-        results.push({ type: "text", content: el.attrs.content, replyMode: config.multisegmentMode });
+        results.push({ type: "text", text: el.attrs.content });
       } else if (el.type === "at") {
-        results.push({ type: "at", content: el.attrs.id, replyMode: config.multisegmentMode });
+        results.push({ type: "at", text: el.attrs.id });
       } else if (el.type === "audio") {
-        results.push({ type: "audio", content: el.attrs.url || el.attrs.path, replyMode: config.multisegmentMode });
+        results.push({ type: "audio", text: el.attrs.src || el.attrs.url });
       } else if (el.type === "video") {
-        results.push({ type: "video", content: el.attrs.src, replyMode: config.multisegmentMode });
+        results.push({ type: "video", text: el.attrs.src });
+      } else {
+        results.push({ type: "unknown", text: JSON.stringify(el) });
       }
     }
     return results;
   }
   __name(parseReplyContent, "parseReplyContent");
-  async function sendFormattedReply(session, replyGroup, authRecord) {
-    const mode = replyGroup[0]?.replyMode || config.multisegmentMode;
-    const replaceVars = /* @__PURE__ */ __name((text) => {
-      if (!text || typeof text !== "string") return text;
-      if (authRecord) {
-        text = text.replace(/\{expiryDate\}/g, formatDate(authRecord.expiryDate));
-        text = text.replace(/\{expiryTime\}/g, formatDate(authRecord.expiryDate));
-        text = text.replace(/\{authorizer\}/g, authRecord.authorizer || "未设置");
-        text = text.replace(/\{channelId\}/g, authRecord.channelId);
-        text = text.replace(/\{updateDate\}/g, formatDate(authRecord.updateDate));
-      } else {
-        text = text.replace(/\{expiryDate\}/g, "未设置");
-        text = text.replace(/\{expiryTime\}/g, "未设置");
-        text = text.replace(/\{authorizer\}/g, "未设置");
-      }
-      return text;
-    }, "replaceVars");
-    if (mode === "1") {
-      for (const item of replyGroup) {
-        if (item.type === "text") {
-          await session.send(h.text(replaceVars(item.content)));
-        } else if (item.type === "image") {
-          await session.send(await formatImageReply(item.content));
-        } else if (item.type === "at") {
-          await session.send(h.at(item.content));
-        } else if (item.type === "audio") {
-          await session.send(h.audio(item.content));
-        } else if (item.type === "video") {
-          await session.send(h.video(item.content));
-        }
-      }
-    } else if (mode === "2") {
-      let combined = "";
-      for (const item of replyGroup) {
-        if (item.type === "text") {
-          combined += replaceVars(item.content) + "\n";
-        } else if (item.type === "image") {
-          await session.send(h.text(combined.trim()));
-          combined = "";
-          await session.send(await formatImageReply(item.content));
-        } else if (item.type === "at") {
-          combined += `@${item.content} `;
-        }
-      }
-      if (combined.trim()) {
-        await session.send(h.text(combined.trim()));
-      }
-    } else if (mode === "3" || mode === "4") {
-      const children = [];
-      for (const item of replyGroup) {
-        if (item.type === "text") {
-          children.push(h.text(replaceVars(item.content)));
-        } else if (item.type === "image") {
-          children.push(await formatImageReply(item.content));
-        } else if (item.type === "at") {
-          children.push(h.at(item.content));
-        }
-      }
-      await session.send(h("figure", {}, children));
-    }
-  }
-  __name(sendFormattedReply, "sendFormattedReply");
-  async function matchKeyword(session, content, isTest = false) {
-    const searchFiles = isTest ? [path.join(dataDir, "test.json")] : [
-      path.join(dataDir, "global.json"),
-      path.join(dataDir, `${session.channelId}.json`)
-    ];
-    for (const filePath of searchFiles) {
-      if (!fsSync.existsSync(filePath)) continue;
-      const data = JSON.parse(fsSync.readFileSync(filePath, "utf-8"));
-      const keys = Object.keys(data).sort((a, b) => {
-        const lenA = a.startsWith("regex:") ? a.slice(6).length : a.length;
-        const lenB = b.startsWith("regex:") ? b.slice(6).length : b.length;
-        return lenB - lenA;
-      });
-      for (const key of keys) {
-        let isMatch = false;
-        let cleanKey = config.treatAsLowercase ? key.toLowerCase() : key;
-        let cleanContent = config.treatAsLowercase ? content.toLowerCase() : content;
-        if (key.startsWith("regex:")) {
-          const pattern = key.slice(6);
-          try {
-            const regex = new RegExp(pattern);
-            isMatch = regex.test(content);
-          } catch (e) {
-            continue;
-          }
-        } else {
-          for (const prefix of config.matchPrefixes) {
-            const prefixedKey = prefix + cleanKey;
-            if (cleanContent === prefixedKey) {
-              isMatch = true;
-              break;
-            }
-            const match = cleanContent.match(new RegExp(`^${escapeRegExp(prefixedKey)}\\s*(\\d+)$`));
-            if (match) {
-              const idx = parseInt(match[1]);
-              if (data[key][idx - 1]) {
-                const authRecord = await ctx.database.get("qxgl_satori_auth", {
-                  platform: session.platform,
-                  channelId: session.channelId
-                }).then((r) => r[0] || null);
-                await sendFormattedReply(session, data[key][idx - 1], authRecord);
-                return true;
-              }
-            }
-          }
-        }
-        if (isMatch) {
-          const limitKey = config.frequencyScope === "channel" ? `${key}:${session.channelId}` : key;
-          const now = Date.now();
-          if (lastTriggerTimes[limitKey] && now - lastTriggerTimes[limitKey] < config.frequencyLimit * 1e3) {
-            return true;
-          }
-          lastTriggerTimes[limitKey] = now;
-          const authRecord = await ctx.database.get("qxgl_satori_auth", {
-            platform: session.platform,
-            channelId: session.channelId
-          }).then((r) => r[0] || null);
-          const replies = data[key];
-          const selected = replies[Math.floor(Math.random() * replies.length)];
-          await sendFormattedReply(session, selected, authRecord);
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  __name(matchKeyword, "matchKeyword");
-  const AUTH_COMMANDS = [
-    "群授权",
-    "私聊授权",
-    "取消授权",
-    "更换授权",
-    "到期时间",
-    "查询到期",
-    "全局延期",
-    "全局减少",
-    "更新名称",
-    "列出已记录群",
-    "备份数据"
-  ];
-  function isAuthCommand(content) {
-    const trimmed = content.trim();
-    for (const cmd of AUTH_COMMANDS) {
-      if (trimmed.startsWith(cmd) || trimmed.startsWith("/" + cmd) || trimmed.startsWith("#" + cmd)) {
-        return true;
+  async function formatReply(reply, record = null) {
+    let formatted;
+    if (reply.type === "image") {
+      formatted = h.image(reply.text);
+    } else if (reply.type === "text") {
+      let text = reply.text;
+      if (record) {
+        text = text.replace(/\{expiryDate\}/g, formatDate(record.expiryDate)).replace(/\{expiryTime\}/g, formatDate(record.expiryDate)).replace(/\{channelId\}/g, record.channelId).replace(/\{authorizer\}/g, record.authorizer || "未设置").replace(/\{updateDate\}/g, formatDate(record.updateDate)).replace(/\{platform\}/g, record.platform);
       }
+      formatted = h.text(text);
+    } else if (reply.type === "at") {
+      formatted = h.at(reply.text);
+    } else if (reply.type === "audio") {
+      formatted = h.audio(reply.text);
+    } else if (reply.type === "video") {
+      formatted = h.video(reply.text);
+    } else {
+      formatted = h.text(String(reply.text));
     }
-    return false;
+    return formatted;
   }
-  __name(isAuthCommand, "isAuthCommand");
-  ctx.middleware(async (session, next) => {
-    const { platform, channelId } = session;
-    if (isAuthCommand(session.content)) {
-      return next();
-    }
-    if (config.authorizationMode !== "disabled") {
-      await ensureChannelRecorded(session);
-    }
-    if (config.authorizationMode === "strict") {
-      const authorized = await isAuthorized(session);
-      if (!authorized) {
-        logInfo(`拦截未授权群消息: ${channelId}`);
-        const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
-        if (record.length > 0 && record[0].expiryDate) {
-          const expired = (/* @__PURE__ */ new Date()).getTime() > new Date(record[0].expiryDate).getTime();
-          if (expired && config.autoLeaveOnExpiry) {
-            try {
-              await session.bot?.leaveGuild?.(channelId);
-            } catch (e) {
-              logger.warn(`自动退群失败: ${e.message}`);
-            }
-          }
-        }
-        return;
-      }
-    }
-    await checkAndUpdateExpiry(session);
-    return next();
-  }, true);
-  ctx.middleware(async (session, next) => {
-    let content = session.content;
-    if (config.unifiedAtField) {
-      content = content.replace(/<at\s+id="(\d+)"[^>]*>/g, '<at id="$1"/>');
-    }
-    content = content.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"');
-    if (config.treatAsLowercase) {
-      content = content.toLowerCase();
-    }
-    let isTest = false;
-    const authRecord = await ctx.database.get("qxgl_satori_auth", {
-      platform: session.platform,
-      channelId: session.channelId
-    });
-    if (authRecord.length > 0 && authRecord[0].testChannels) {
-      const testChannels = authRecord[0].testChannels;
-      isTest = testChannels.includes(session.channelId) || testChannels.includes(`private:${session.userId}`);
+  __name(formatReply, "formatReply");
+  async function authorizeGroup(session, channelId, months, authorizer = "蒙面人") {
+    if (!channelId || !months) {
+      await session.send("格式错误：群授权 <群号> <±月数> [授权人]");
+      return;
     }
-    const matched = await matchKeyword(session, content, isTest);
-    if (matched) return;
-    return next();
-  });
-  ctx.command(pluginName);
-  ctx.command(pluginName + "/群授权 <channelId> <months> [authorizer]", "群授权管理", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, channelId, months, authorizer = "蒙面人") => {
-    if (!channelId || !months) return "格式错误：群授权 <群号> <±月数> [授权人]";
     const monthsNum = parseInt(months);
-    if (isNaN(monthsNum)) return "请输入有效的月份数（正数增加，负数减少）";
-    let groupName = "未知群聊";
-    try {
-      if (session.bot?.getGuild) {
-        const guild = await session.bot.getGuild(channelId);
-        groupName = guild?.name || groupName;
-      }
-    } catch (e) {
+    if (isNaN(monthsNum)) {
+      await session.send("请提供有效的月份数（正整数表示增加，负整数表示减少）");
+      return;
     }
-    const { platform } = session;
-    const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
+    const platform = session.platform;
+    let record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
     const now = /* @__PURE__ */ new Date();
-    let newExpiry;
+    let newExpiryDate;
     if (record.length === 0) {
-      newExpiry = new Date(now.getFullYear(), now.getMonth() + monthsNum, now.getDate());
+      newExpiryDate = new Date(now.getFullYear(), now.getMonth() + monthsNum, now.getDate());
       await ctx.database.create("qxgl_satori_auth", {
         platform,
         channelId,
-        expiryDate: newExpiry,
-        isBlocked: false,
+        isAuthorized: true,
+        expiryDate: newExpiryDate,
         authorizer,
-        channelName: groupName,
-        updateDate: now,
-        testChannels: []
+        channelName: "",
+        recordDate: now,
+        updateDate: now
       });
     } else {
-      const current = record[0].expiryDate ? new Date(record[0].expiryDate) : now;
-      newExpiry = new Date(current.getFullYear(), current.getMonth() + monthsNum, current.getDate());
+      const currentExpiry = record[0].expiryDate ? new Date(record[0].expiryDate) : now;
+      newExpiryDate = new Date(currentExpiry.getFullYear(), currentExpiry.getMonth() + monthsNum, currentExpiry.getDate());
       await ctx.database.set("qxgl_satori_auth", { platform, channelId }, {
-        expiryDate: newExpiry,
+        isAuthorized: true,
+        expiryDate: newExpiryDate,
         authorizer,
-        channelName: groupName,
-        updateDate: now,
-        isBlocked: false
+        updateDate: now
       });
     }
     const action = monthsNum > 0 ? "增加" : "减少";
-    return `群号 "${channelId}" 授权已${action} ${Math.abs(monthsNum)} 个月
-到期时间：${formatDate(newExpiry)}
-授权人：${authorizer}
-更新日期：${formatDate(now)}`;
-  });
-  ctx.command(pluginName + "/私聊授权 <userId> <months> [authorizer]", "私聊授权管理", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, userId, months, authorizer = "蒙面人") => {
-    if (!userId || !months) return "格式错误：私聊授权 <用户ID> <±月数> [授权人]";
+    await session.send(`群号 "${channelId}" 授权已${action} ${Math.abs(monthsNum)} 个月
+新到期时间：${formatDate(newExpiryDate)}
+授权人：${authorizer}`);
+  }
+  __name(authorizeGroup, "authorizeGroup");
+  async function authorizePrivate(session, userId, months, authorizer = "蒙面人") {
+    if (!userId || !months) {
+      await session.send("格式错误：私聊授权 <用户ID> <±月数> [授权人]");
+      return;
+    }
     const monthsNum = parseInt(months);
-    if (isNaN(monthsNum)) return "请输入有效的月份数";
+    if (isNaN(monthsNum)) {
+      await session.send("请提供有效的月份数");
+      return;
+    }
+    const platform = session.platform;
     const channelId = `private:${userId}`;
-    const { platform } = session;
-    const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
+    let record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
     const now = /* @__PURE__ */ new Date();
-    let newExpiry;
+    let newExpiryDate;
     if (record.length === 0) {
-      newExpiry = new Date(now.getFullYear(), now.getMonth() + monthsNum, now.getDate());
+      newExpiryDate = new Date(now.getFullYear(), now.getMonth() + monthsNum, now.getDate());
       await ctx.database.create("qxgl_satori_auth", {
         platform,
         channelId,
-        expiryDate: newExpiry,
-        isBlocked: false,
+        isAuthorized: true,
+        expiryDate: newExpiryDate,
         authorizer,
         channelName: "私聊",
-        updateDate: now,
-        testChannels: []
+        recordDate: now,
+        updateDate: now
       });
     } else {
-      const current = record[0].expiryDate ? new Date(record[0].expiryDate) : now;
-      newExpiry = new Date(current.getFullYear(), current.getMonth() + monthsNum, current.getDate());
+      const currentExpiry = record[0].expiryDate ? new Date(record[0].expiryDate) : now;
+      newExpiryDate = new Date(currentExpiry.getFullYear(), currentExpiry.getMonth() + monthsNum, currentExpiry.getDate());
       await ctx.database.set("qxgl_satori_auth", { platform, channelId }, {
-        expiryDate: newExpiry,
+        isAuthorized: true,
+        expiryDate: newExpiryDate,
         authorizer,
-        updateDate: now,
-        isBlocked: false
+        updateDate: now
       });
     }
     const action = monthsNum > 0 ? "增加" : "减少";
-    return `用户 "${userId}" 授权已${action} ${Math.abs(monthsNum)} 个月
-到期时间：${formatDate(newExpiry)}
-授权人：${authorizer}`;
-  });
-  ctx.command(pluginName + "/取消授权 <targetId>", "取消指定群/私聊授权", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, targetId) => {
-    if (!targetId) return "请提供目标ID";
+    await session.send(`用户 "${userId}" 授权已${action} ${Math.abs(monthsNum)} 个月
+新到期时间：${formatDate(newExpiryDate)}`);
+  }
+  __name(authorizePrivate, "authorizePrivate");
+  async function cancelAuthorization(session, targetId) {
+    if (!targetId) {
+      await session.send("请提供有效的群号或用户ID");
+      return;
+    }
+    const platform = session.platform;
     const channelId = targetId.startsWith("private:") ? targetId : targetId;
-    const { platform } = session;
     const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
-    if (record.length === 0) return `未找到授权记录：${targetId}`;
-    await ctx.database.remove("qxgl_satori_auth", { platform, channelId });
-    return `已取消授权：${targetId}`;
-  });
-  ctx.command(pluginName + "/更换授权 <sourceId> <targetId>", "迁移授权数据", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, sourceId, targetId) => {
-    if (!sourceId || !targetId) return "格式：更换授权 <原ID> <新ID>";
-    const sourceChannel = sourceId.startsWith("private:") ? sourceId : sourceId;
-    const targetChannel = targetId.startsWith("private:") ? targetId : targetId;
-    const { platform } = session;
-    const source = await ctx.database.get("qxgl_satori_auth", { platform, channelId: sourceChannel });
-    if (source.length === 0) return `原目标未找到：${sourceId}`;
-    const target = await ctx.database.get("qxgl_satori_auth", { platform, channelId: targetChannel });
-    if (target.length > 0) return `新目标已存在授权：${targetId}`;
-    const data = source[0];
+    if (record.length === 0) {
+      await session.send("未找到该目标的授权记录");
+    } else {
+      await ctx.database.remove("qxgl_satori_auth", { platform, channelId });
+      await session.send(`授权已取消：${targetId}`);
+    }
+  }
+  __name(cancelAuthorization, "cancelAuthorization");
+  async function changeAuthorization(session, sourceId, targetId) {
+    if (!sourceId || !targetId) {
+      await session.send("格式错误：更换授权 <原群号> <新群号>");
+      return;
+    }
+    const platform = session.platform;
+    const sourceChannelId = sourceId.startsWith("private:") ? sourceId : sourceId;
+    const targetChannelId = targetId.startsWith("private:") ? targetId : targetId;
+    const sourceRecord = await ctx.database.get("qxgl_satori_auth", { platform, channelId: sourceChannelId });
+    if (sourceRecord.length === 0) {
+      await session.send("未找到原目标的授权记录");
+      return;
+    }
+    const targetRecord = await ctx.database.get("qxgl_satori_auth", { platform, channelId: targetChannelId });
+    if (targetRecord.length > 0) {
+      await session.send("新目标已存在授权记录，请先取消");
+      return;
+    }
     await ctx.database.create("qxgl_satori_auth", {
-      ...data,
-      channelId: targetChannel,
-      channelName: "新迁移群聊",
+      platform,
+      channelId: targetChannelId,
+      isAuthorized: sourceRecord[0].isAuthorized,
+      expiryDate: sourceRecord[0].expiryDate,
+      authorizer: sourceRecord[0].authorizer,
+      channelName: "新授权群聊",
+      recordDate: /* @__PURE__ */ new Date(),
       updateDate: /* @__PURE__ */ new Date()
     });
-    await ctx.database.remove("qxgl_satori_auth", { platform, channelId: sourceChannel });
-    return `授权已从 ${sourceId} 迁移到 ${targetId}`;
-  });
-  ctx.command(pluginName + "/到期时间", "查询当前授权到期时间", {
-    authority: 0
-  }).action(async ({ session }) => {
-    const { platform, channelId } = session;
+    await ctx.database.remove("qxgl_satori_auth", { platform, channelId: sourceChannelId });
+    await session.send(`授权已从 ${sourceId} 更换到 ${targetId}`);
+  }
+  __name(changeAuthorization, "changeAuthorization");
+  async function checkExpiryTime(session) {
+    const platform = session.platform;
+    const channelId = session.channelId;
     const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
     if (record.length === 0 || !record[0].expiryDate) {
-      return "当前未设置到期时间（永久授权或无授权记录）";
+      await session.send(`未设置到期时间，默认到期：${config.defaultExpiry}`);
+    } else {
+      const auth = record[0];
+      await session.send(`本群授权到期：${formatDate(auth.expiryDate)}
+授权人：${auth.authorizer || "蒙面人"}
+更新日期：${formatDate(auth.updateDate)}`);
     }
-    return `到期时间：${formatDate(record[0].expiryDate)}
-授权人：${record[0].authorizer || "未知"}
-更新于：${formatDate(record[0].updateDate)}`;
-  });
-  ctx.command(pluginName + "/查询到期 <targetId>", "查询指定目标授权", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, targetId) => {
+  }
+  __name(checkExpiryTime, "checkExpiryTime");
+  async function queryTargetExpiry(session, targetId) {
+    if (!targetId) {
+      await session.send("请提供有效的群号或用户ID");
+      return;
+    }
+    const platform = session.platform;
     const channelId = targetId.startsWith("private:") ? targetId : targetId;
-    const record = await ctx.database.get("qxgl_satori_auth", {
-      platform: session.platform,
-      channelId
-    });
-    if (record.length === 0) return `未找到授权记录：${targetId}`;
-    return `目标：${targetId}
-到期：${formatDate(record[0].expiryDate)}
-授权人：${record[0].authorizer || "未知"}`;
-  });
-  ctx.command(pluginName + "/全局延期 <days>", "为所有授权增加天数", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, days) => {
-    const d = parseInt(days);
-    if (isNaN(d) || d <= 0) return "请输入正整数天数";
+    const record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
+    if (record.length === 0) {
+      await session.send("未找到授权记录");
+    } else {
+      await session.send(`目标授权到期：${formatDate(record[0].expiryDate)}
+授权人：${record[0].authorizer || "蒙面人"}`);
+    }
+  }
+  __name(queryTargetExpiry, "queryTargetExpiry");
+  async function globalDelayExpiry(session, days) {
+    const daysNum = parseInt(days);
+    if (isNaN(daysNum) || daysNum <= 0) {
+      await session.send("请输入有效的延期天数（正整数）");
+      return;
+    }
     const records = await ctx.database.get("qxgl_satori_auth");
     const now = /* @__PURE__ */ new Date();
     let count = 0;
-    for (const r of records) {
-      if (!r.expiryDate) continue;
-      if (new Date(r.expiryDate).getTime() <= now.getTime()) continue;
-      const newDate = new Date(new Date(r.expiryDate).getTime() + d * 864e5);
-      await ctx.database.set(
-        "qxgl_satori_auth",
-        { platform: r.platform, channelId: r.channelId },
-        { expiryDate: newDate, updateDate: now }
-      );
-      count++;
-    }
-    return `已为 ${count} 个有效授权延期 ${d} 天`;
-  });
-  ctx.command(pluginName + "/全局减少 <days>", "为所有授权减少天数", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, days) => {
-    const d = parseInt(days);
-    if (isNaN(d) || d <= 0) return "请输入正整数天数";
+    for (const record of records) {
+      if (record.expiryDate) {
+        const currentExpiry = new Date(record.expiryDate);
+        if (currentExpiry <= now) continue;
+        const newExpiry = new Date(currentExpiry.getTime() + daysNum * 24 * 60 * 60 * 1e3);
+        await ctx.database.set(
+          "qxgl_satori_auth",
+          { platform: record.platform, channelId: record.channelId },
+          { expiryDate: newExpiry, updateDate: now }
+        );
+        count++;
+      }
+    }
+    await session.send(`已成功为 ${count} 个群聊延期 ${daysNum} 天`);
+  }
+  __name(globalDelayExpiry, "globalDelayExpiry");
+  async function globalReduceExpiry(session, days) {
+    const daysNum = parseInt(days);
+    if (isNaN(daysNum) || daysNum <= 0) {
+      await session.send("请输入有效的减少天数（正整数）");
+      return;
+    }
     const records = await ctx.database.get("qxgl_satori_auth");
     const now = /* @__PURE__ */ new Date();
     let count = 0;
-    for (const r of records) {
-      if (!r.expiryDate) continue;
-      if (new Date(r.expiryDate).getTime() <= now.getTime()) continue;
-      const newDate = new Date(new Date(r.expiryDate).getTime() - d * 864e5);
-      await ctx.database.set(
-        "qxgl_satori_auth",
-        { platform: r.platform, channelId: r.channelId },
-        { expiryDate: newDate, updateDate: now }
-      );
-      count++;
-    }
-    return `已为 ${count} 个授权减少 ${d} 天`;
-  });
-  ctx.command(pluginName + "/更新名称", "刷新群名称缓存", {
-    authority: config.commandAuthority
-  }).action(async ({ session }) => {
+    for (const record of records) {
+      if (record.expiryDate) {
+        const currentExpiry = new Date(record.expiryDate);
+        if (currentExpiry <= now) continue;
+        const newExpiry = new Date(currentExpiry.getTime() - daysNum * 24 * 60 * 60 * 1e3);
+        await ctx.database.set(
+          "qxgl_satori_auth",
+          { platform: record.platform, channelId: record.channelId },
+          { expiryDate: newExpiry, updateDate: now }
+        );
+        count++;
+      }
+    }
+    await session.send(`已成功为 ${count} 个群聊减少 ${daysNum} 天`);
+  }
+  __name(globalReduceExpiry, "globalReduceExpiry");
+  async function updateChannelName(session) {
     const records = await ctx.database.get("qxgl_satori_auth");
     let count = 0;
-    for (const r of records) {
-      if (r.channelId.startsWith("private:")) continue;
+    for (const record of records) {
+      if (record.channelId.startsWith("private:")) continue;
       try {
-        if (session.bot?.getGuild) {
-          const guild = await session.bot.getGuild(r.channelId);
-          if (guild?.name) {
-            await ctx.database.set(
-              "qxgl_satori_auth",
-              { platform: r.platform, channelId: r.channelId },
-              { channelName: guild.name }
-            );
-            count++;
-          }
+        const guild = await session.bot.getGuild?.(record.channelId);
+        if (guild?.name) {
+          await ctx.database.set(
+            "qxgl_satori_auth",
+            { platform: record.platform, channelId: record.channelId },
+            { channelName: guild.name }
+          );
+          count++;
         }
       } catch (e) {
       }
     }
-    return `已更新 ${count} 个群名称`;
-  });
-  ctx.command(pluginName + "/列出已记录群", "列出所有群授权状态", {
-    authority: config.commandAuthority
-  }).action(async () => {
+    await session.send(`已更新 ${count} 个群聊名称`);
+  }
+  __name(updateChannelName, "updateChannelName");
+  async function listChannels(session) {
     const records = await ctx.database.get("qxgl_satori_auth");
-    const groups = records.filter((r) => !r.channelId.startsWith("private:"));
-    if (groups.length === 0) return "暂无群记录";
-    return groups.map(
-      (r) => `群名：${r.channelName}
+    if (!records.length) return "暂无群聊记录";
+    const list = records.filter((r) => !r.channelId.startsWith("private:")).map((r) => `群名：${r.channelName || "未知"}
 群号：${r.channelId}
+平台：${r.platform}
 到期：${formatDate(r.expiryDate)}
-授权：${r.authorizer}
-状态：${r.isBlocked ? "已拉黑" : "正常"}`
-    ).join("\n\n");
-  });
-  ctx.command(pluginName + "/备份数据", "备份数据到JSON", {
-    authority: config.commandAuthority
-  }).action(async () => {
+授权人：${r.authorizer || "蒙面人"}`).join("\n\n");
+    await session.send(list || "暂无群聊记录");
+  }
+  __name(listChannels, "listChannels");
+  async function backupData(session) {
     const records = await ctx.database.get("qxgl_satori_auth");
-    const backupPath = path.join(dataDir, `backup_${Date.now()}.json`);
+    const backupPath = path.join(root, `backup_${Date.now()}.json`);
     await fs.writeFile(backupPath, JSON.stringify(records, null, 2));
-    return `已备份 ${records.length} 条记录到 ${backupPath}`;
-  });
-  async function addKeywordLogic(session, keyword, isGlobal = false, isRegex = false) {
-    if (!keyword) return "请输入关键词";
-    const filePath = isGlobal ? getFilePath(null, true) : getFilePath(session.channelId);
-    if (!fsSync.existsSync(filePath)) {
-      fsSync.writeFileSync(filePath, "{}");
-    }
-    let data;
+    await session.send(`已备份 ${records.length} 条授权记录到 ${backupPath}`);
+  }
+  __name(backupData, "backupData");
+  async function addKeywordReply(session, keyword, isGlobal = false, isTest = false, isRegex = false) {
+    const filePath = isTest ? testFile : isGlobal ? globalFile : getChannelFile(session.platform, session.channelId);
+    let data = {};
     try {
-      data = JSON.parse(fsSync.readFileSync(filePath, "utf-8"));
+      const content = await fs.readFile(filePath, "utf-8");
+      data = JSON.parse(content);
     } catch {
-      data = {};
-    }
-    const key = isRegex ? `regex:${keyword}` : config.treatAsLowercase ? keyword.toLowerCase() : keyword;
-    if (data[key] && config.handleDuplicate === "reject") {
-      return `关键词 "${keyword}" 已存在`;
-    }
-    if (!data[key] || config.handleDuplicate === "replace") {
-      data[key] = [];
-    }
-    if (config.alwaysPrompt !== "never") {
-      await session.send('请输入回复内容（支持多段，输入"结束添加"完成，"取消添加"放弃）：');
     }
+    let key = keyword;
+    if (config.treatAllAsLowercase) key = key.toLowerCase();
+    if (isRegex) key = `regex:${key}`;
+    if (!data[key]) data[key] = [];
+    await session.send(config.prompt);
+    const timeout = config.addKeywordTime * 6e4;
     const replies = [];
-    const timeout = config.addTimeout * 6e4;
     while (true) {
-      if (config.alwaysPrompt === "always") {
-        await session.send("请继续输入（结束添加/取消添加）：");
-      }
       const reply = await session.prompt(timeout);
-      if (!reply) return "输入超时，已取消";
-      if (reply.includes(config.cancelKeyword)) return "已取消添加";
-      if (reply.includes(config.endKeyword)) break;
-      const parsed = await parseReplyContent(reply, isGlobal ? "global" : session.channelId);
+      if (!reply) {
+        await session.send("输入超时，操作已取消");
+        return;
+      }
+      if (reply.includes(config.keywordOfEsc)) {
+        await session.send("操作已取消");
+        return;
+      }
+      if (config.matchPatternForExit !== "1") {
+        if (config.matchPatternForExit === "2" && reply === config.keywordOfEnd || config.matchPatternForExit === "3" && reply.includes(config.keywordOfEnd) || config.matchPatternForExit === "4" && (reply === config.keywordOfEnd || reply.includes(config.keywordOfEnd))) {
+          break;
+        }
+      }
+      const parsed = await parseReplyContent(reply, session.channelId, isGlobal, isTest);
       replies.push(...parsed);
+      if (config.matchPatternForExit === "1") break;
+    }
+    if (replies.length === 0) {
+      await session.send("未输入有效内容");
+      return;
     }
-    if (replies.length === 0) return "未输入有效回复";
     data[key].push(replies);
-    fsSync.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    return `关键词 "${keyword}" 添加完成，共 ${data[key].length} 条回复`;
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+    await session.send(`关键词 "${keyword}" 的回复已添加（当前共 ${data[key].length} 条回复）`);
   }
-  __name(addKeywordLogic, "addKeywordLogic");
-  ctx.command(pluginName + `/${config.triggerPrefix} [keyword]`, "添加关键词", {
-    authority: config.commandAuthority
-  }).option("regex", "-x 使用正则匹配").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "添加")) return "权限不足";
-    return addKeywordLogic(session, keyword, false, options.regex);
-  });
-  ctx.command(pluginName + `/${config.globalTriggerPrefix} [keyword]`, "添加全局关键词", {
-    authority: config.commandAuthority
-  }).option("regex", "-x 使用正则匹配").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "全局添加")) return "权限不足";
-    return addKeywordLogic(session, keyword, true, options.regex);
-  });
-  async function deleteKeywordLogic(session, keyword, isGlobal, index = null) {
-    if (!keyword) return "请输入关键词";
-    const filePath = isGlobal ? getFilePath(null, true) : getFilePath(session.channelId);
-    if (!fsSync.existsSync(filePath)) return "暂无数据";
-    const data = JSON.parse(fsSync.readFileSync(filePath, "utf-8"));
-    const searchKey = config.treatAsLowercase ? keyword.toLowerCase() : keyword;
-    let targetKey = null;
-    for (const k of Object.keys(data)) {
-      const cleanK = k.startsWith("regex:") ? k.slice(6) : k;
-      if (cleanK === searchKey) {
-        targetKey = k;
-        break;
-      }
+  __name(addKeywordReply, "addKeywordReply");
+  async function deleteKeywordReply(session, keyword, isGlobal = false, index = null, isTest = false) {
+    let filePath;
+    if (isTest) {
+      filePath = testFile;
+    } else if (isGlobal) {
+      filePath = globalFile;
+    } else {
+      filePath = getChannelFile(session.platform, session.channelId);
+    }
+    let data = {};
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      data = JSON.parse(content);
+    } catch {
+      await session.send("该关键词不存在");
+      return;
+    }
+    let key = config.treatAllAsLowercase ? keyword.toLowerCase() : keyword;
+    if (!data[key]) {
+      const keys = Object.keys(data);
+      const found = keys.find((k) => config.treatAllAsLowercase ? k.toLowerCase() === key : k === key);
+      if (found) key = found;
+    }
+    if (!data[key]) {
+      await session.send(`关键词 "${keyword}" 不存在`);
+      return;
+    }
+    if (config.deleteBranchOnly && data[key].length > 1 && index === null) {
+      await session.send(`该关键词有 ${data[key].length} 条回复，请指定序号删除：删除 -q <序号> ${keyword}`);
+      return;
+    }
+    if (index !== null && index > 0 && index <= data[key].length) {
+      data[key].splice(index - 1, 1);
+      if (data[key].length === 0) delete data[key];
+      await session.send(`已删除第 ${index} 条回复`);
+    } else {
+      delete data[key];
+      await session.send(`关键词 "${keyword}" 已删除`);
+    }
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+  }
+  __name(deleteKeywordReply, "deleteKeywordReply");
+  async function fixKeywordReply(session, keyword, isGlobal = false, index = 1, isTest = false) {
+    let filePath;
+    if (isTest) {
+      filePath = testFile;
+    } else if (isGlobal) {
+      filePath = globalFile;
+    } else {
+      filePath = getChannelFile(session.platform, session.channelId);
+    }
+    let data = {};
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      data = JSON.parse(content);
+    } catch {
+      await session.send("未找到问答数据");
+      return;
+    }
+    let key = config.treatAllAsLowercase ? keyword.toLowerCase() : keyword;
+    if (!data[key]) {
+      await session.send(`关键词 "${keyword}" 不存在`);
+      return;
+    }
+    const idx = index - 1;
+    if (idx < 0 || idx >= data[key].length) {
+      await session.send("指定的回复序号无效");
+      return;
+    }
+    let currentContent = "";
+    for (const item of data[key][idx]) {
+      currentContent += await formatReply(item);
+    }
+    await session.send(`当前第 ${index} 条回复：
+${currentContent}
+
+请输入新内容（输入 ${config.keywordOfEsc} 取消）：`);
+    const timeout = config.addKeywordTime * 6e4;
+    const reply = await session.prompt(timeout);
+    if (!reply) {
+      await session.send("输入超时");
+      return;
+    }
+    if (reply.includes(config.keywordOfEsc)) {
+      await session.send("操作已取消");
+      return;
+    }
+    const parsed = await parseReplyContent(reply, session.channelId, isGlobal, isTest);
+    data[key][idx] = parsed;
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2));
+    await session.send("回复已修改");
+  }
+  __name(fixKeywordReply, "fixKeywordReply");
+  async function viewKeywords(session) {
+    const files = [];
+    if (config.searchRange === "1" || config.searchRange === "3") {
+      files.push(getChannelFile(session.platform, session.channelId));
     }
-    if (!targetKey) return `关键词 "${keyword}" 不存在`;
-    if (config.deleteBranchOnly && data[targetKey].length > 1 && index === null) {
-      return `该关键词有 ${data[targetKey].length} 条回复，请使用 -q 指定序号删除`;
+    if (config.searchRange === "2" || config.searchRange === "3") {
+      files.push(globalFile);
     }
-    if (index !== null) {
-      const idx = parseInt(index) - 1;
-      if (isNaN(idx) || idx < 0 || idx >= data[targetKey].length) {
-        return "无效的回复序号";
+    let keywords = [];
+    for (const file of files) {
+      try {
+        const content = await fs.readFile(file, "utf-8");
+        const data = JSON.parse(content);
+        keywords = keywords.concat(Object.keys(data));
+      } catch {
       }
-      data[targetKey].splice(idx, 1);
-      if (data[targetKey].length === 0) {
-        delete data[targetKey];
-        fsSync.writeFileSync(filePath, JSON.stringify(data, null, 2));
-        return `已删除关键词 "${keyword}"`;
+    }
+    keywords = [...new Set(keywords)];
+    if (keywords.length === 0) {
+      await session.send("当前没有关键词");
+      return;
+    }
+    await session.send(`关键词列表（共 ${keywords.length} 个）：
+${keywords.join("\n")}`);
+  }
+  __name(viewKeywords, "viewKeywords");
+  async function searchKeyword(session, keyword) {
+    const files = [];
+    if (config.searchRange === "1" || config.searchRange === "3") {
+      files.push(getChannelFile(session.platform, session.channelId));
+    }
+    if (config.searchRange === "2" || config.searchRange === "3") {
+      files.push(globalFile);
+    }
+    const results = [];
+    const searchKey = config.treatAllAsLowercase ? keyword.toLowerCase() : keyword;
+    for (const file of files) {
+      try {
+        const content = await fs.readFile(file, "utf-8");
+        const data = JSON.parse(content);
+        for (const [k, v] of Object.entries(data)) {
+          const checkKey = config.treatAllAsLowercase ? k.toLowerCase() : k;
+          if (checkKey.includes(searchKey)) {
+            const arr = v;
+            results.push(`关键词：${k}（${file.includes("global") ? "全局" : "本群"}）
+回复数量：${arr.length}`);
+            if (config.searchRange === "2") break;
+          }
+        }
+      } catch {
       }
-      fsSync.writeFileSync(filePath, JSON.stringify(data, null, 2));
-      return `已删除 "${keyword}" 的第 ${index} 条回复`;
+    }
+    if (results.length === 0) {
+      await session.send(`未找到包含 "${keyword}" 的关键词`);
     } else {
-      delete data[targetKey];
-      fsSync.writeFileSync(filePath, JSON.stringify(data, null, 2));
-      return `已删除关键词 "${keyword}"`;
+      await session.send(results.join("\n\n"));
     }
   }
-  __name(deleteKeywordLogic, "deleteKeywordLogic");
-  ctx.command(pluginName + `/${config.deletePrefix} [keyword]`, "删除关键词", {
-    authority: config.commandAuthority
-  }).option("index", "-q <number> 指定回复序号").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "删除")) return "权限不足";
-    return deleteKeywordLogic(session, keyword, false, options.index);
-  });
-  ctx.command(pluginName + `/${config.globalDeletePrefix} [keyword]`, "删除全局关键词", {
-    authority: config.commandAuthority
-  }).option("index", "-q <number> 指定回复序号").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "全局删除")) return "权限不足";
-    return deleteKeywordLogic(session, keyword, true, options.index);
-  });
-  async function fixKeywordLogic(session, keyword, isGlobal, idx = 0) {
-    if (!keyword) return "请输入关键词";
-    const filePath = isGlobal ? getFilePath(null, true) : getFilePath(session.channelId);
-    if (!fsSync.existsSync(filePath)) return "文件不存在";
-    const data = JSON.parse(fsSync.readFileSync(filePath, "utf-8"));
-    const searchKey = config.treatAsLowercase ? keyword.toLowerCase() : keyword;
-    let targetKey = null;
-    for (const k of Object.keys(data)) {
-      const cleanK = k.startsWith("regex:") ? k.slice(6) : k;
-      if (cleanK === searchKey) targetKey = k;
-    }
-    if (!targetKey) return `关键词 "${keyword}" 不存在`;
-    if (!data[targetKey][idx]) return "回复序号无效";
-    await session.send(`正在修改 "${keyword}" 的第 ${idx + 1} 条回复，当前内容：`);
-    await sendFormattedReply(session, data[targetKey][idx], null);
-    await session.send("请输入新内容（取消添加 放弃）：");
-    const reply = await session.prompt(config.addTimeout * 6e4);
-    if (!reply || reply.includes(config.cancelKeyword)) return "已取消";
-    const parsed = await parseReplyContent(reply, isGlobal ? "global" : session.channelId);
-    data[targetKey][idx] = parsed;
-    fsSync.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    return "修改完成";
+  __name(searchKeyword, "searchKeyword");
+  function isTestChannel(platform, channelId) {
+    const fullId = `${platform}:${channelId}`;
+    return config.testChannels.includes(fullId);
   }
-  __name(fixKeywordLogic, "fixKeywordLogic");
-  ctx.command(pluginName + `/${config.fixCommand} [keyword]`, "修改关键词", {
-    authority: config.commandAuthority
-  }).option("index", "-q <number> 回复序号").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "修改")) return "权限不足";
-    return fixKeywordLogic(session, keyword, false, (options.index || 1) - 1);
-  });
-  ctx.command(pluginName + `/${config.globalFixCommand} [keyword]`, "修改全局关键词", {
-    authority: config.commandAuthority
-  }).option("index", "-q <number> 回复序号").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "全局修改")) return "权限不足";
-    return fixKeywordLogic(session, keyword, true, (options.index || 1) - 1);
-  });
-  ctx.command(pluginName + `/${config.searchCommand} [keyword]`, "查找关键词", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, keyword) => {
-    if (!hasPermission(session, "查找关键词")) return "权限不足";
-    if (!keyword) return "请输入搜索词";
-    let files = [];
-    if (config.searchRange === "local") {
-      files = [getFilePath(session.channelId)];
-    } else if (config.searchRange === "all") {
-      files = fsSync.readdirSync(dataDir).filter((f) => f.endsWith(".json")).map((f) => path.join(dataDir, f));
+  __name(isTestChannel, "isTestChannel");
+  async function addTestChannel(session, targetId) {
+    const fullId = targetId.includes(":") ? targetId : `${session.platform}:${targetId}`;
+    if (!config.testChannels.includes(fullId)) {
+      config.testChannels.push(fullId);
+      await session.send(`已将 ${fullId} 加入测试名单`);
     } else {
-      files = [getFilePath(session.channelId), getFilePath(null, true)];
+      await session.send(`${fullId} 已在测试名单中`);
+    }
+  }
+  __name(addTestChannel, "addTestChannel");
+  async function removeTestChannel(session, targetId) {
+    const fullId = targetId.includes(":") ? targetId : `${session.platform}:${targetId}`;
+    const idx = config.testChannels.indexOf(fullId);
+    if (idx > -1) {
+      config.testChannels.splice(idx, 1);
+      await session.send(`已将 ${fullId} 移出测试名单`);
+    } else {
+      await session.send(`${fullId} 不在测试名单中`);
+    }
+  }
+  __name(removeTestChannel, "removeTestChannel");
+  async function syncTestData(session) {
+    try {
+      await fs.copyFile(globalFile, testFile);
+      const content = await fs.readFile(testFile, "utf-8");
+      const data = JSON.parse(content);
+      await session.send(`测试同步完成，共 ${Object.keys(data).length} 条问答已复制到测试环境`);
+    } catch (error) {
+      await session.send("同步失败：" + error.message);
+    }
+  }
+  __name(syncTestData, "syncTestData");
+  async function publishTestData(session) {
+    try {
+      if (!fsSync.existsSync(testFile)) {
+        await session.send("测试问答文件不存在");
+        return;
+      }
+      const backupFile = path.join(root, `global.json.bak.${Date.now()}`);
+      await fs.copyFile(globalFile, backupFile);
+      await fs.copyFile(testFile, globalFile);
+      const content = await fs.readFile(globalFile, "utf-8");
+      const data = JSON.parse(content);
+      await session.send(`测试发布完成，共 ${Object.keys(data).length} 条问答已发布到全局
+原全局文件已备份`);
+    } catch (error) {
+      await session.send("发布失败：" + error.message);
+    }
+  }
+  __name(publishTestData, "publishTestData");
+  ctx.middleware(async (session, next) => {
+    if (isAuthCommand(session.content)) {
+      logInfo(`授权指令免疫：${session.content.substring(0, 20)}...`);
+      return next();
+    }
+    return next();
+  }, true);
+  ctx.middleware(async (session, next) => {
+    if (!config.enableAuthSystem) return next();
+    const { platform, channelId } = session;
+    let record = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
+    if (record.length === 0 && config.autoRecordChannel) {
+      await ctx.database.create("qxgl_satori_auth", {
+        platform,
+        channelId,
+        isAuthorized: false,
+        expiryDate: null,
+        authorizer: "",
+        channelName: "",
+        recordDate: /* @__PURE__ */ new Date(),
+        updateDate: /* @__PURE__ */ new Date()
+      });
+      logInfo(`自动记录新群：${platform}:${channelId}`);
+      return;
+    } else if (record.length === 0) {
+      return;
+    }
+    const auth = record[0];
+    if (auth.expiryDate) {
+      const expiry = new Date(auth.expiryDate);
+      if (/* @__PURE__ */ new Date() > expiry) {
+        await ctx.database.set("qxgl_satori_auth", { platform, channelId }, { isAuthorized: false });
+        if (config.autoLeaveOnExpiry) {
+          try {
+            await session.bot.leaveGuild?.(channelId);
+          } catch (e) {
+            logger.warn(`自动退群失败：${e.message}`);
+          }
+        }
+        return;
+      }
+    }
+    if (!auth.isAuthorized) {
+      return;
+    }
+    return next();
+  }, true);
+  ctx.middleware(async (session, next) => {
+    let content = unescapeHtml(session.content).trim();
+    if (config.treatAllAsLowercase) content = content.toLowerCase();
+    if (config.unifiedAtField) {
+      content = content.replace(/<at id="(\d+)" name="[^"]*"\s*\/>/g, '<at id="$1"/>');
     }
-    let results = [];
+    logInfo(`处理消息：${content.substring(0, 50)}...`);
+    const isTest = isTestChannel(session.platform, session.channelId);
+    const files = isTest ? [testFile] : config.searchRange === "3" ? [globalFile, getChannelFile(session.platform, session.channelId)] : [globalFile];
+    const makeKey = /* @__PURE__ */ __name((keyword) => config.restrictionType === "2" ? `${keyword}:${session.channelId}` : keyword, "makeKey");
     for (const file of files) {
-      if (!fsSync.existsSync(file)) continue;
-      const data = JSON.parse(fsSync.readFileSync(file, "utf-8"));
-      for (const k of Object.keys(data)) {
-        if (k.includes(keyword)) {
-          results.push(`在 ${path.basename(file, ".json")} 找到：${k}（${data[k].length}条回复）`);
+      try {
+        const data = JSON.parse(await fs.readFile(file, "utf-8"));
+        const keys = Object.keys(data).sort((a, b) => {
+          const lenA = a.startsWith("regex:") ? a.slice(6).length : a.length;
+          const lenB = b.startsWith("regex:") ? b.slice(6).length : b.length;
+          return lenB - lenA;
+        });
+        for (const key of keys) {
+          let isMatch = false;
+          let replyIndex = 0;
+          const realKey = key.startsWith("regex:") ? key.slice(6) : key;
+          for (const prefix of config.prefix) {
+            const fullKey = prefix + realKey;
+            if (content === fullKey) {
+              isMatch = true;
+              break;
+            }
+            const suffixMatch = content.match(new RegExp(`^${escapeRegExp(fullKey)}\\s*(\\d+)$`));
+            if (suffixMatch) {
+              isMatch = true;
+              replyIndex = parseInt(suffixMatch[1]) - 1;
+              break;
+            }
+          }
+          if (!isMatch && key.startsWith("regex:")) {
+            const regex = new RegExp(realKey);
+            if (regex.test(content)) isMatch = true;
+          }
+          if (isMatch) {
+            const now = Date.now();
+            const limitKey = makeKey(key);
+            if (config.frequencyLimitation > 0 && lastTriggerTimes[limitKey]) {
+              if (now - lastTriggerTimes[limitKey] < config.frequencyLimitation * 1e3) {
+                logInfo("频率限制触发，跳过回复");
+                return;
+              }
+            }
+            lastTriggerTimes[limitKey] = now;
+            const replies = data[key];
+            if (replyIndex >= replies.length) replyIndex = 0;
+            const selected = replies[replyIndex] || replies[Math.floor(Math.random() * replies.length)];
+            const authRecord = await ctx.database.get("qxgl_satori_auth", {
+              platform: session.platform,
+              channelId: session.channelId
+            });
+            for (const item of selected) {
+              const formatted = await formatReply(item, authRecord[0]);
+              await session.send(formatted);
+            }
+            return;
+          }
         }
+      } catch (error) {
+        if (error.code !== "ENOENT") logger.error(`读取问答文件失败：${error.message}`);
       }
     }
-    return results.length ? results.slice(0, 10).join("\n") : "未找到";
+    return next();
   });
-  ctx.command(pluginName + `/${config.viewListCommand}`, "查看关键词列表", {
-    authority: config.commandAuthority
-  }).action(async ({ session }) => {
-    if (!hasPermission(session, "查看关键词列表")) return "权限不足";
-    const filePath = getFilePath(session.channelId);
-    const globalPath = getFilePath(null, true);
-    let keys = [];
-    if (config.searchRange !== "local" && fsSync.existsSync(globalPath)) {
-      keys.push(...Object.keys(JSON.parse(fsSync.readFileSync(globalPath, "utf-8"))).map((k) => `[全]${k}`));
-    }
-    if (fsSync.existsSync(filePath)) {
-      keys.push(...Object.keys(JSON.parse(fsSync.readFileSync(filePath, "utf-8"))).map((k) => `[本]${k}`));
-    }
-    if (keys.length === 0) return "暂无关键词";
-    return keys.join("\n");
+  ctx.command(pluginName).action(({ session }) => {
+    return "使用帮助：请查看插件说明文档";
   });
-  ctx.command(pluginName + "/测试授权 <targetId...>", "加入测试名单", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, ...targets) => {
-    if (!targets.length) return "请提供目标ID";
-    const allRecords = await ctx.database.get("qxgl_satori_auth");
-    let testChannels = [];
-    if (allRecords.length > 0 && allRecords[0].testChannels) {
-      testChannels = allRecords[0].testChannels;
-    }
-    const added = [];
-    for (const t of targets) {
-      const cid = t.startsWith("private:") ? t : t;
-      if (!testChannels.includes(cid)) {
-        testChannels.push(cid);
-        added.push(t);
-      }
+  ctx.command(`${pluginName}/${config.commandGroupAuth} <channelId> <months> [authorizer]`, "群授权管理").authority(config.commandAuthority).action(async ({ session }, channelId, months, authorizer) => {
+    if (!hasPermission(session, config.commandGroupAuth)) {
+      return "权限不足";
     }
-    if (added.length > 0) {
-      await ctx.database.set("qxgl_satori_auth", {}, { testChannels });
+    await authorizeGroup(session, channelId, months, authorizer);
+  });
+  ctx.command(`${pluginName}/${config.commandPrivateAuth} <userId> <months> [authorizer]`, "私聊授权管理").authority(config.commandAuthority).action(async ({ session }, userId, months, authorizer) => {
+    if (!hasPermission(session, config.commandPrivateAuth)) {
+      return "权限不足";
     }
-    return `已添加测试：${added.join("、") || "无新增"}`;
+    await authorizePrivate(session, userId, months, authorizer);
   });
-  ctx.command(pluginName + "/取消测试授权 <targetId...>", "移出测试名单", {
-    authority: config.commandAuthority
-  }).action(async ({ session }, ...targets) => {
-    const allRecords = await ctx.database.get("qxgl_satori_auth");
-    if (!allRecords.length) return "无数据";
-    let testChannels = allRecords[0].testChannels || [];
-    const removed = [];
-    for (const t of targets) {
-      const idx = testChannels.indexOf(t);
-      if (idx > -1) {
-        testChannels.splice(idx, 1);
-        removed.push(t);
-      } else if (t.startsWith("private:")) {
-        const plain = t.replace("private:", "");
-        const idx2 = testChannels.indexOf(plain);
-        if (idx2 > -1) {
-          testChannels.splice(idx2, 1);
-          removed.push(t);
-        }
-      }
+  ctx.command(`${pluginName}/${config.commandCancelAuth} <targetId>`, "取消授权").authority(config.commandAuthority).action(async ({ session }, targetId) => {
+    if (!hasPermission(session, config.commandCancelAuth)) {
+      return "权限不足";
     }
-    await ctx.database.set("qxgl_satori_auth", {}, { testChannels });
-    return `已移出：${removed.join("、") || "无"}`;
+    await cancelAuthorization(session, targetId);
   });
-  ctx.command(pluginName + "/测试同步", "正式→测试数据同步", {
-    authority: config.commandAuthority
-  }).action(async () => {
-    const globalPath = getFilePath(null, true);
-    if (!fsSync.existsSync(globalPath)) return "全局文件不存在";
-    fsSync.copyFileSync(globalPath, testFilePath);
-    const count = Object.keys(JSON.parse(fsSync.readFileSync(testFilePath, "utf-8"))).length;
-    return `测试同步完成，共 ${count} 条数据`;
+  ctx.command(`${pluginName}/${config.commandChangeAuth} <sourceId> <targetId>`, "更换授权").authority(config.commandAuthority).action(async ({ session }, sourceId, targetId) => {
+    if (!hasPermission(session, config.commandChangeAuth)) {
+      return "权限不足";
+    }
+    await changeAuthorization(session, sourceId, targetId);
   });
-  ctx.command(pluginName + "/测试发布", "测试→正式发布（带备份）", {
-    authority: config.commandAuthority
-  }).alias("测试转正").action(async () => {
-    if (!fsSync.existsSync(testFilePath)) return "测试文件不存在";
-    const globalPath = getFilePath(null, true);
-    const backupPath = path.join(dataDir, `global.json.bak_${Date.now()}`);
-    if (fsSync.existsSync(globalPath)) {
-      fsSync.copyFileSync(globalPath, backupPath);
-    }
-    fsSync.copyFileSync(testFilePath, globalPath);
-    const count = Object.keys(JSON.parse(fsSync.readFileSync(globalPath, "utf-8"))).length;
-    return `测试发布完成，共 ${count} 条数据，原数据已备份`;
+  ctx.command(`${pluginName}/${config.commandQueryExpiry}`, "查询本群到期时间").action(async ({ session }) => {
+    await checkExpiryTime(session);
   });
-  ctx.command(pluginName + "/测试添加 <keyword>", "测试环境添加", {
-    authority: config.commandAuthority
-  }).option("regex", "-x").action(async ({ session, options }, keyword) => {
-    if (!hasPermission(session, "测试添加")) return "权限不足";
-    if (!fsSync.existsSync(testFilePath)) fsSync.writeFileSync(testFilePath, "{}");
-    let data = JSON.parse(fsSync.readFileSync(testFilePath, "utf-8"));
-    const key = options.regex ? `regex:${keyword}` : keyword;
-    if (config.alwaysPrompt !== "never") {
-      await session.send("【测试模式】请输入回复内容（结束添加/取消添加）：");
+  ctx.command(`${pluginName}/${config.commandQueryTargetExpiry} <targetId>`, "查询指定目标到期时间").authority(config.commandAuthority).action(async ({ session }, targetId) => {
+    if (!hasPermission(session, config.commandQueryTargetExpiry)) {
+      return "权限不足";
     }
-    const replies = [];
-    const timeout = config.addTimeout * 6e4;
-    while (true) {
-      const reply = await session.prompt(timeout);
-      if (!reply) return "超时";
-      if (reply.includes(config.cancelKeyword)) return "取消";
-      if (reply.includes(config.endKeyword)) break;
-      const parsed = await parseReplyContent(reply, "test");
-      replies.push(...parsed);
+    await queryTargetExpiry(session, targetId);
+  });
+  ctx.command(`${pluginName}/${config.commandGlobalDelay} <days>`, "全局延期").authority(config.commandAuthority).action(async ({ session }, days) => {
+    if (!hasPermission(session, config.commandGlobalDelay)) {
+      return "权限不足";
+    }
+    await globalDelayExpiry(session, days);
+  });
+  ctx.command(`${pluginName}/${config.commandGlobalReduce} <days>`, "全局减少").authority(config.commandAuthority).action(async ({ session }, days) => {
+    if (!hasPermission(session, config.commandGlobalReduce)) {
+      return "权限不足";
+    }
+    await globalReduceExpiry(session, days);
+  });
+  ctx.command(`${pluginName}/${config.commandUpdateName}`, "更新群名称缓存").authority(config.commandAuthority).action(async ({ session }) => {
+    if (!hasPermission(session, config.commandUpdateName)) {
+      return "权限不足";
+    }
+    await updateChannelName(session);
+  });
+  ctx.command(`${pluginName}/${config.commandListChannels}`, "列出所有已记录群").authority(config.commandAuthority).action(async ({ session }) => {
+    if (!hasPermission(session, config.commandListChannels)) {
+      return "权限不足";
+    }
+    await listChannels(session);
+  });
+  ctx.command(`${pluginName}/${config.commandBackup} [filename]`, "备份授权数据").authority(config.commandAuthority).action(async ({ session }) => {
+    if (!hasPermission(session, config.commandBackup)) {
+      return "权限不足";
+    }
+    await backupData(session);
+  });
+  ctx.command(`${pluginName}/${config.commandAddKeyword} <keyword>`, "添加关键词").option("regex", "-x 使用正则匹配").option("global", "-g 添加到全局").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandAddKeyword)) {
+      return "权限不足";
+    }
+    await addKeywordReply(session, keyword, options.global, false, options.regex);
+  });
+  ctx.command(`${pluginName}/${config.commandGlobalAddKeyword} <keyword>`, "全局添加关键词").option("regex", "-x 使用正则匹配").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandGlobalAddKeyword)) {
+      return "权限不足";
+    }
+    await addKeywordReply(session, keyword, true, false, options.regex);
+  });
+  ctx.command(`${pluginName}/${config.commandDeleteKeyword} <keyword>`, "删除关键词").option("question", "-q <number> 指定删除的回复序号").option("global", "-g 删除全局关键词").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandDeleteKeyword)) {
+      return "权限不足";
+    }
+    await deleteKeywordReply(session, keyword, options.global, options.question);
+  });
+  ctx.command(`${pluginName}/${config.commandGlobalDeleteKeyword} <keyword>`, "全局删除关键词").option("question", "-q <number> 指定删除的回复序号").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandGlobalDeleteKeyword)) {
+      return "权限不足";
+    }
+    await deleteKeywordReply(session, keyword, true, options.question);
+  });
+  ctx.command(`${pluginName}/${config.commandFixKeyword} <keyword>`, "修改关键词回复").option("question", "-q <number> 指定回复序号（默认1）").option("global", "-g 修改全局关键词").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandFixKeyword)) {
+      return "权限不足";
+    }
+    await fixKeywordReply(session, keyword, options.global, options.question || 1);
+  });
+  ctx.command(`${pluginName}/${config.commandGlobalFixKeyword} <keyword>`, "全局修改关键词").option("question", "-q <number> 指定回复序号").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandGlobalFixKeyword)) {
+      return "权限不足";
+    }
+    await fixKeywordReply(session, keyword, true, options.question || 1);
+  });
+  ctx.command(`${pluginName}/${config.commandViewKeywords}`, "查看关键词列表").authority(config.commandAuthority).action(async ({ session }) => {
+    if (!hasPermission(session, config.commandViewKeywords)) {
+      return "权限不足";
+    }
+    await viewKeywords(session);
+  });
+  ctx.command(`${pluginName}/${config.commandSearchKeyword} <keyword>`, "查找关键词").authority(config.commandAuthority).action(async ({ session }, keyword) => {
+    if (!hasPermission(session, config.commandSearchKeyword)) {
+      return "权限不足";
+    }
+    await searchKeyword(session, keyword);
+  });
+  ctx.command(`${pluginName}/${config.commandTestAuth} <targetId>`, "将频道加入测试名单").authority(config.commandAuthority).action(async ({ session }, targetId) => {
+    if (!hasPermission(session, config.commandTestAuth)) {
+      return "权限不足";
+    }
+    await addTestChannel(session, targetId);
+  });
+  ctx.command(`${pluginName}/${config.commandCancelTestAuth} <targetId>`, "将频道移出测试名单").authority(config.commandAuthority).action(async ({ session }, targetId) => {
+    if (!hasPermission(session, config.commandCancelTestAuth)) {
+      return "权限不足";
+    }
+    await removeTestChannel(session, targetId);
+  });
+  ctx.command(`${pluginName}/${config.commandTestSync}`, "同步全局到测试环境").authority(config.commandAuthority).action(async ({ session }) => {
+    if (!hasPermission(session, config.commandTestSync)) {
+      return "权限不足";
+    }
+    await syncTestData(session);
+  });
+  ctx.command(`${pluginName}/${config.commandTestPublish}`, "发布测试到全局环境").authority(config.commandAuthority).action(async ({ session }) => {
+    if (!hasPermission(session, config.commandTestPublish)) {
+      return "权限不足";
+    }
+    await publishTestData(session);
+  });
+  ctx.command(`${pluginName}/${config.commandTestAdd} <keyword>`, "测试环境添加关键词").option("regex", "-x 使用正则").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandTestAdd)) {
+      return "权限不足";
+    }
+    await addKeywordReply(session, keyword, false, true, options.regex);
+  });
+  ctx.command(`${pluginName}/${config.commandTestDelete} <keyword>`, "测试环境删除关键词").option("question", "-q <number> 指定序号").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandTestDelete)) {
+      return "权限不足";
+    }
+    await deleteKeywordReply(session, keyword, false, options.question, true);
+  });
+  ctx.command(`${pluginName}/${config.commandTestFix} <keyword>`, "测试环境修改关键词").option("question", "-q <number> 指定序号").authority(config.commandAuthority).action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, config.commandTestFix)) {
+      return "权限不足";
+    }
+    await fixKeywordReply(session, keyword, false, options.question || 1, true);
+  });
+  ctx.on("guild-member", async (session) => {
+    if (session.subtype !== "ban" || session.userId !== session.selfId) return;
+    if (!config.autoLeaveOnMute) return;
+    try {
+      await session.bot.leaveGuild?.(session.guildId || session.channelId);
+      logger.info(`被禁言自动退群：${session.channelId}`);
+    } catch (e) {
+      logger.warn(`自动退群失败：${e.message}`);
+    }
+  });
+  ctx.on("guild-added", async (session) => {
+    if (!config.enableAuthSystem || !config.autoRecordChannel) return;
+    const platform = session.platform;
+    const channelId = session.channelId || session.guildId;
+    if (!channelId) return;
+    const exists = await ctx.database.get("qxgl_satori_auth", { platform, channelId });
+    if (exists.length === 0) {
+      await ctx.database.create("qxgl_satori_auth", {
+        platform,
+        channelId,
+        isAuthorized: false,
+        expiryDate: null,
+        authorizer: "",
+        channelName: session.guildName || "",
+        recordDate: /* @__PURE__ */ new Date(),
+        updateDate: /* @__PURE__ */ new Date()
+      });
+      logger.info(`入群自动记录：${platform}:${channelId}`);
     }
-    if (!data[key]) data[key] = [];
-    data[key].push(replies);
-    fsSync.writeFileSync(testFilePath, JSON.stringify(data, null, 2));
-    return `测试关键词 ${keyword} 已添加`;
   });
-  if (config.autoLeaveOnMute) {
-    ctx.on("guild-member", async (session) => {
-      if (session.subtype !== "ban" || session.selfId !== session.userId) return;
-      try {
-        await session.bot?.leaveGuild?.(session.guildId);
-        logger.info(`被禁言自动退群：${session.guildId}`);
-      } catch (e) {
-        logger.warn(`退群失败：${e.message}`);
-      }
-    });
-  }
 }
 __name(apply, "apply");
-function formatDate(date) {
-  if (!date) return "未设置";
-  const d = new Date(date);
-  const year = d.getFullYear();
-  const month = (d.getMonth() + 1).toString().padStart(2, "0");
-  const day = d.getDate().toString().padStart(2, "0");
-  return `${year}/${month}/${day}`;
-}
-__name(formatDate, "formatDate");
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-__name(escapeRegExp, "escapeRegExp");
 exports.apply = apply;
 exports.Config = Config;
 exports.name = pluginName;