koishi-plugin-qxgl-satori 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,14 @@
+declare var __defProp: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
+declare var __name: (target: any, value: any) => any;
+declare var koishi: any;
+declare var Schema: any, Logger: any, h: any;
+declare var logger: any;
+declare var inject: string[];
+declare var pluginName: string;
+declare var fs: any;
+declare var fsPromises: any;
+declare var path: any;
+declare var pathToFileURL: any;
+declare var Config: any;
+declare var usage: string;
+declare function apply(ctx: any, config: any): Promise<void>;

package/lib/index.js

@@ -0,0 +1,975 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// 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"];
+var pluginName = "qxgl-satori";
+var fs = require("node:fs");
+var fsPromises = require("node:fs/promises");
+var path = require("node:path");
+var { pathToFileURL } = require("node:url");
+var Config = Schema.intersect([
+  Schema.object({
+    enableAuthSystem: Schema.boolean().default(true).description("启用授权系统（关闭时所有群可用，但仍记录群信息）"),
+    autoLeaveOnMute: Schema.boolean().default(true).description("被禁言时自动退群"),
+    autoLeaveOnExpiry: Schema.boolean().default(true).description("授权到期时自动退群"),
+    commandAuthority: Schema.number().default(3).description("授权管理指令所需权限等级"),
+    pictureStrategy: Schema.union([
+      Schema.const("auto").description("自动检测（Satori用路径，OneBot用file://）"),
+      Schema.const("http").description("强制HTTP服务（需配置对外可访问地址）")
+    ]).default("auto").description("图片发送策略"),
+    httpServePath: Schema.string().default("http://localhost:5140/qxgl-satori").description("图片HTTP服务基础地址（使用HTTP策略时）")
+  }).description("授权系统设置"),
+  Schema.object({
+    defaultImageExtension: Schema.union(["jpg", "png", "gif"]).default("png").description("图片保存后缀"),
+    addKeywordTime: Schema.number().role("slider").min(1).max(30).step(1).default(5).description("添加回复输入时限（分钟）"),
+    Treat_all_as_lowercase: Schema.boolean().default(true).description("英文关键词匹配无视大小写"),
+    Delete_Branch_Only: Schema.boolean().default(true).description("删除多段回复时必须指定序号"),
+    HandleDuplicateKeywords: Schema.union([
+      Schema.const("1").description("直接替换/覆盖"),
+      Schema.const("2").description("并列添加（随机选择）"),
+      Schema.const("3").description("禁止重复")
+    ]).default("2").description("重复关键词处理"),
+    MultisegmentAdditionRecoveryEffect: Schema.union([
+      Schema.const("1").description("原版输入，原版输出（多段消息）"),
+      Schema.const("2").description("合为图文消息/多行消息（一次发出）"),
+      Schema.const("3").description("合为图文消息并合并转发"),
+      Schema.const("4").description("原版输入，合并转发发送")
+    ]).default("2").description("多段回复效果"),
+    Frequency_limitation: Schema.number().default(0).description("同一问答最小触发间隔（秒，0为不限制）"),
+    Type_of_restriction: Schema.union([
+      Schema.const("1").description("对同一个问题（全部对象）"),
+      Schema.const("2").description("仅对同一个频道（不同频道独立）")
+    ]).default("2").description("最小间隔限制对象"),
+    Search_Range: Schema.union([
+      Schema.const("1").description("仅在当前频道"),
+      Schema.const("2").description("搜索全部频道"),
+      Schema.const("3").description("当前频道+全局")
+    ]).default("3").description("搜索范围"),
+    Find_Return_Preset: Schema.union([
+      Schema.const("1").description("仅返回问答内容"),
+      Schema.const("2").description("仅返回位置"),
+      Schema.const("3").description("返回内容和位置")
+    ]).default("1").description("查找返回信息"),
+    Return_Limit: Schema.union([
+      Schema.const("1").description("返回全部"),
+      Schema.const("2").description("仅返回一条")
+    ]).default("2").description("返回限制"),
+    MatchPatternForExit: Schema.union([
+      Schema.const("1").description("仅接受一次性输入"),
+      Schema.const("2").description("完全匹配结束词退出"),
+      Schema.const("3").description("包含结束词退出"),
+      Schema.const("4").description("完全匹配或包含均可退出")
+    ]).default("4").description("退出添加方式"),
+    AlwayPrompt: Schema.union([
+      Schema.const("1").description("不返回提示"),
+      Schema.const("2").description("仅返回一次"),
+      Schema.const("3").description("每次输入都返回")
+    ]).default("2").description("提示方式"),
+    Prompt: Schema.string().role("textarea", { rows: [2, 4] }).default("请输入回复内容（输入 取消添加 以取消，输入 结束添加 以结束）：").description("添加提示文字"),
+    KeywordOfEsc: Schema.string().default("取消添加").description("取消添加关键词"),
+    KeywordOfEnd: Schema.string().default("结束添加").description("结束添加关键词")
+  }).description("关键词问答设置"),
+  Schema.object({
+    admin_list: Schema.array(Schema.object({
+      adminID: Schema.string().description("管理员用户ID"),
+      allowcommand: Schema.array(Schema.union([
+        "添加",
+        "全局添加",
+        "删除",
+        "全局删除",
+        "修改",
+        "全局修改",
+        "查找关键词",
+        "查看关键词列表",
+        "群授权",
+        "私聊授权",
+        "到期时间",
+        "查询到期",
+        "全局延期",
+        "全局减少",
+        "更新名称",
+        "列出已记录群",
+        "取消授权",
+        "更换授权",
+        "测试授权",
+        "取消测试授权",
+        "测试同步",
+        "测试发布",
+        "测试添加",
+        "测试删除",
+        "测试修改"
+      ])).default(["到期时间"]).description("可使用的指令")
+    })).role("table").description("管理员列表（0代表所有用户）").default([{ adminID: "0" }]),
+    channel_admin_auth: Schema.boolean().default(false).description("开启后自动允许群主/管理员使用全部指令（需适配器支持）")
+  }).description("权限设置"),
+  Schema.object({
+    loggerinfo: Schema.boolean().default(false).description("日志调试模式")
+  }).description("调试设置")
+]);
+var usage = `<!DOCTYPE html>
+<html lang="zh">
+<head>
+<meta charset="UTF-8">
+<title>qxgl-satori 插件使用说明</title>
+</head>
+<body>
+<h1>插件功能说明</h1>
+<p>qxgl-satori 整合了群/私聊授权管理和关键词问答功能，支持多账号共享授权数据，Satori 原生适配。</p>
+<h2>授权管理指令</h2>
+<ul>
+  <li><strong>群授权 &lt;群号&gt; &lt;±月数&gt; [授权人]</strong> - 授权/修改群到期时间（支持负数减少）</li>
+  <li><strong>私聊授权 &lt;用户ID&gt; &lt;±月数&gt; [授权人]</strong> - 私聊授权</li>
+  <li><strong>取消授权 &lt;目标ID&gt;</strong> - 删除授权记录</li>
+  <li><strong>更换授权 &lt;原ID&gt; &lt;新ID&gt;</strong> - 转移授权</li>
+  <li><strong>到期时间</strong> - 查询当前群/私聊到期时间</li>
+  <li><strong>查询到期 [目标ID]</strong> - 查询指定目标（无参数查当前）</li>
+  <li><strong>全局延期 &lt;天数&gt;</strong> - 所有群统一延期</li>
+  <li><strong>全局减少 &lt;天数&gt;</strong> - 所有群统一减少</li>
+  <li><strong>列出已记录群</strong> - 显示所有群授权信息</li>
+  <li><strong>更新名称</strong> - 刷新所有群名称缓存</li>
+</ul>
+<h2>关键词指令</h2>
+<ul>
+  <li><strong>添加 &lt;关键词&gt; [-x] [-f]</strong> - 添加关键词（-x正则，-f指定回复方式1-4）</li>
+  <li><strong>全局添加 &lt;关键词&gt; [-x] [-f]</strong> - 添加全局关键词</li>
+  <li><strong>删除 &lt;关键词&gt; [-q &lt;序号&gt;]</strong> - 删除关键词（-q删指定分支）</li>
+  <li><strong>全局删除 &lt;关键词&gt; [-q &lt;序号&gt;]</strong> - 删除全局关键词</li>
+  <li><strong>修改 &lt;关键词&gt; [-q &lt;序号&gt;]</strong> - 修改回复</li>
+  <li><strong>全局修改 &lt;关键词&gt; [-q &lt;序号&gt;]</strong> - 修改全局回复</li>
+  <li><strong>查找关键词 &lt;关键词&gt;</strong> - 模糊搜索</li>
+  <li><strong>查看关键词列表</strong> - 显示图文关键词列表</li>
+</ul>
+<h2>测试环境指令</h2>
+<ul>
+  <li><strong>测试授权 &lt;目标ID...&gt;</strong> - 将群/私聊加入测试名单</li>
+  <li><strong>取消测试授权 &lt;目标ID...&gt;</strong> - 移出测试名单</li>
+  <li><strong>测试同步</strong> - 全局问答复制到测试环境</li>
+  <li><strong>测试发布</strong> - 测试问答发布到全局（自动备份）</li>
+  <li><strong>测试添加/删除/修改</strong> - 同正式指令，仅操作测试数据</li>
+</ul>
+</body>
+</html>`;
+async function apply(ctx, config) {
+  const root = path.join(ctx.baseDir, "data", "qxgl-satori");
+  if (!fs.existsSync(root)) {
+    fs.mkdirSync(root, { recursive: true });
+  }
+  const globalFile = path.join(root, "global.json");
+  const testFile = path.join(root, "test.json");
+  if (!fs.existsSync(globalFile)) fs.writeFileSync(globalFile, "{}");
+  if (!fs.existsSync(testFile)) fs.writeFileSync(testFile, "{}");
+  let lastTriggerTimes = {};
+  function logInfo(message) {
+    if (config.loggerinfo) logger.info(message);
+  }
+  __name(logInfo, "logInfo");
+  function isSatoriAdapter(session) {
+    return session?.bot?.adapter?.name?.includes("satori") || session?.bot?.constructor?.name?.toLowerCase().includes("satori") || false;
+  }
+  __name(isSatoriAdapter, "isSatoriAdapter");
+  ctx.model.extend("qxgl_satori_auth", {
+    platform: "string",
+    channelId: "string",
+    expiryDate: "date",
+    isblockedchannel: "boolean",
+    authorizer: "string",
+    channelName: "string",
+    updateDate: "date",
+    testChannels: "list"
+  }, {
+    primary: ["platform", "channelId"]
+    // 多账号共享关键：移除 selfId
+  });
+  async function updateChannelName(session) {
+    if (!session.channelId || session.channelId.startsWith("private:")) return "私聊";
+    let name = "未知群聊";
+    try {
+      if (session.bot && typeof session.bot.getGuild === "function") {
+        const info = await session.bot.getGuild(session.channelId);
+        name = info?.name || name;
+      }
+    } catch (e) {
+      logInfo(`获取群名失败: ${e.message}`);
+    }
+    return name;
+  }
+  __name(updateChannelName, "updateChannelName");
+  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 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 defaultConfig = config.admin_list.find((a) => a.adminID === "0");
+    if (defaultConfig?.allowcommand?.includes(commandName)) return true;
+    const userConfig = config.admin_list.find((a) => a.adminID === userId);
+    if (userConfig?.allowcommand?.includes(commandName)) return true;
+    if (config.channel_admin_auth && isAdmin(session)) return true;
+    return false;
+  }
+  __name(hasPermission, "hasPermission");
+  async function authorizeGroup(session, channelId, months, authorizer) {
+    if (!channelId || !months) return "请提供群号和月数";
+    const monthsNum = parseInt(months);
+    if (isNaN(monthsNum)) return "月数必须是数字";
+    const channelName = await updateChannelName({ ...session, channelId });
+    const currentDate = /* @__PURE__ */ new Date();
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId
+    });
+    let newExpiryDate;
+    if (!record) {
+      newExpiryDate = new Date(currentDate.getFullYear(), currentDate.getMonth() + monthsNum, currentDate.getDate());
+      await ctx.database.create("qxgl_satori_auth", {
+        platform: session.platform,
+        channelId,
+        expiryDate: newExpiryDate,
+        isblockedchannel: false,
+        authorizer: authorizer || "蒙面人",
+        channelName,
+        updateDate: currentDate,
+        testChannels: []
+      });
+    } else {
+      const currentExpiry = record.expiryDate ? new Date(record.expiryDate) : currentDate;
+      newExpiryDate = new Date(currentExpiry.getFullYear(), currentExpiry.getMonth() + monthsNum, currentExpiry.getDate());
+      await ctx.database.set(
+        "qxgl_satori_auth",
+        { platform: session.platform, channelId },
+        {
+          expiryDate: newExpiryDate,
+          isblockedchannel: false,
+          authorizer: authorizer || "蒙面人",
+          channelName,
+          updateDate: currentDate
+        }
+      );
+    }
+    return `群号 "${channelId}" 的授权已${monthsNum > 0 ? "增加" : "减少"} ${Math.abs(monthsNum)} 个月
+新的到期时间：${formatDate(newExpiryDate)}
+开启人：${authorizer || "蒙面人"}
+更新日期：${formatDate(currentDate)}`;
+  }
+  __name(authorizeGroup, "authorizeGroup");
+  async function authorizePrivate(session, userId, months, authorizer) {
+    if (!userId || !months) return "请提供用户ID和月数";
+    const monthsNum = parseInt(months);
+    if (isNaN(monthsNum)) return "月数必须是数字";
+    const channelId = `private:${userId}`;
+    const currentDate = /* @__PURE__ */ new Date();
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId
+    });
+    let newExpiryDate;
+    if (!record) {
+      newExpiryDate = new Date(currentDate.getFullYear(), currentDate.getMonth() + monthsNum, currentDate.getDate());
+      await ctx.database.create("qxgl_satori_auth", {
+        platform: session.platform,
+        channelId,
+        expiryDate: newExpiryDate,
+        isblockedchannel: false,
+        authorizer: authorizer || "蒙面人",
+        channelName: "私聊",
+        updateDate: currentDate,
+        testChannels: []
+      });
+    } else {
+      const currentExpiry = record.expiryDate ? new Date(record.expiryDate) : currentDate;
+      newExpiryDate = new Date(currentExpiry.getFullYear(), currentExpiry.getMonth() + monthsNum, currentExpiry.getDate());
+      await ctx.database.set(
+        "qxgl_satori_auth",
+        { platform: session.platform, channelId },
+        {
+          expiryDate: newExpiryDate,
+          authorizer: authorizer || "蒙面人",
+          updateDate: currentDate
+        }
+      );
+    }
+    return `用户ID "${userId}" 的授权已${monthsNum > 0 ? "增加" : "减少"} ${Math.abs(monthsNum)} 个月
+新的到期时间：${formatDate(newExpiryDate)}`;
+  }
+  __name(authorizePrivate, "authorizePrivate");
+  async function cancelAuthorization(session, targetId) {
+    if (!targetId) return "请提供目标ID";
+    const channelId = targetId.startsWith("private:") ? targetId : targetId;
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId
+    });
+    if (!record) return `未找到授权记录：${targetId}`;
+    await ctx.database.remove("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId
+    });
+    return `授权已取消：${targetId}`;
+  }
+  __name(cancelAuthorization, "cancelAuthorization");
+  async function changeAuthorization(session, sourceId, targetId) {
+    if (!sourceId || !targetId) return "请提供原ID和新ID";
+    const sourceChannelId = sourceId.startsWith("private:") ? sourceId : sourceId;
+    const targetChannelId = targetId.startsWith("private:") ? targetId : targetId;
+    const [sourceRecord] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: sourceChannelId
+    });
+    if (!sourceRecord) return `未找到原授权记录：${sourceId}`;
+    const [targetRecord] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: targetChannelId
+    });
+    if (targetRecord) return `新目标已存在授权记录：${targetId}`;
+    await ctx.database.create("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: targetChannelId,
+      expiryDate: sourceRecord.expiryDate,
+      isblockedchannel: sourceRecord.isblockedchannel,
+      authorizer: sourceRecord.authorizer,
+      channelName: "新授权",
+      updateDate: /* @__PURE__ */ new Date(),
+      testChannels: sourceRecord.testChannels || []
+    });
+    await ctx.database.remove("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: sourceChannelId
+    });
+    return `授权已从 ${sourceId} 更换到 ${targetId}`;
+  }
+  __name(changeAuthorization, "changeAuthorization");
+  async function checkExpiryTime(session) {
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: session.channelId
+    });
+    if (!record || !record.expiryDate) {
+      return `未设置到期时间`;
+    } else {
+      return `本次使用由《${record.authorizer || "蒙面人"}》激活
+到期时间：${formatDate(record.expiryDate)}`;
+    }
+  }
+  __name(checkExpiryTime, "checkExpiryTime");
+  async function queryExpiryTime(session, targetId) {
+    if (!targetId) {
+      return await checkExpiryTime(session);
+    }
+    const channelId = targetId.startsWith("private:") ? targetId : targetId;
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId
+    });
+    if (!record || !record.expiryDate) {
+      return `未找到授权记录：${targetId}`;
+    } else {
+      return `授权到期时间：${formatDate(record.expiryDate)}
+开启人：${record.authorizer || "蒙面人"}`;
+    }
+  }
+  __name(queryExpiryTime, "queryExpiryTime");
+  async function globalDelayExpiry(session, days) {
+    const daysNum = parseInt(days);
+    if (isNaN(daysNum) || daysNum <= 0) return "请输入有效的天数（正整数）";
+    const records = await ctx.database.get("qxgl_satori_auth");
+    const currentDate = /* @__PURE__ */ new Date();
+    let updatedCount = 0;
+    for (const record of records) {
+      if (record.expiryDate) {
+        const currentExpiry = new Date(record.expiryDate);
+        if (currentExpiry <= currentDate) 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: currentDate }
+        );
+        updatedCount++;
+      }
+    }
+    return `已为 ${updatedCount} 个群聊延期 ${daysNum} 天`;
+  }
+  __name(globalDelayExpiry, "globalDelayExpiry");
+  async function globalReduceExpiry(session, days) {
+    const daysNum = parseInt(days);
+    if (isNaN(daysNum) || daysNum <= 0) return "请输入有效的天数（正整数）";
+    const records = await ctx.database.get("qxgl_satori_auth");
+    const currentDate = /* @__PURE__ */ new Date();
+    let updatedCount = 0;
+    for (const record of records) {
+      if (record.expiryDate) {
+        const currentExpiry = new Date(record.expiryDate);
+        if (currentExpiry <= currentDate) 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: currentDate }
+        );
+        updatedCount++;
+      }
+    }
+    return `已为 ${updatedCount} 个群聊减少 ${daysNum} 天`;
+  }
+  __name(globalReduceExpiry, "globalReduceExpiry");
+  function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  __name(escapeRegExp, "escapeRegExp");
+  async function downloadImage(url, rootDir, isGlobal, session) {
+    try {
+      const buf = await ctx.http.get(url, { responseType: "arraybuffer" }).then((r) => Buffer.from(r));
+      const folder = path.join(rootDir, isGlobal ? "global" : `${session.platform}_${session.channelId}`);
+      await fsPromises.mkdir(folder, { recursive: true });
+      const fileName = `${Date.now()}_${Math.random().toString(36).slice(2)}.${config.defaultImageExtension}`;
+      const localPath = path.join(folder, fileName);
+      await fsPromises.writeFile(localPath, buf);
+      return localPath;
+    } catch (e) {
+      logger.error(`下载图片失败: ${e.message}`);
+      throw new Error(`图片下载失败，请更换链接`);
+    }
+  }
+  __name(downloadImage, "downloadImage");
+  async function parseReplyContent(reply, rootDir, session, options) {
+    const elements = h.parse(reply);
+    const results = [];
+    for (const element of elements) {
+      let item = null;
+      if (element.type === "img" || element.type === "image") {
+        const localPath = await downloadImage(element.attrs.src, rootDir, options.global, session);
+        item = {
+          type: "image",
+          text: localPath,
+          fileSize: element.attrs.fileSize || "",
+          replyway: options.forward || config.MultisegmentAdditionRecoveryEffect
+        };
+      } else if (element.type === "text") {
+        item = {
+          type: "text",
+          text: element.attrs.content,
+          replyway: options.forward || config.MultisegmentAdditionRecoveryEffect
+        };
+      } else if (element.type === "at") {
+        item = {
+          type: "at",
+          text: element.attrs.id,
+          replyway: options.forward || config.MultisegmentAdditionRecoveryEffect
+        };
+      } else if (element.type === "audio") {
+        item = { type: "audio", text: element.attrs.path || element.attrs.url, replyway: options.forward || config.MultisegmentAdditionRecoveryEffect };
+      } else if (element.type === "video") {
+        item = { type: "video", text: element.attrs.src, replyway: options.forward || config.MultisegmentAdditionRecoveryEffect };
+      }
+      if (item) results.push(item);
+    }
+    return results;
+  }
+  __name(parseReplyContent, "parseReplyContent");
+  async function formatReply(reply, session) {
+    if (reply.type === "image") {
+      if (config.pictureStrategy === "http") {
+        const fileName = path.basename(reply.text);
+        const url = `${config.httpServePath}/${reply.text.includes("/global/") ? "global/" : ""}${fileName}`;
+        return h.image(url);
+      } else {
+        if (isSatoriAdapter(session)) {
+          return h.image(reply.text);
+        } else {
+          if (!reply.text.startsWith("http") && !reply.text.startsWith("data:")) {
+            return h.image(pathToFileURL(reply.text).href);
+          }
+          return h.image(reply.text);
+        }
+      }
+    } else if (reply.type === "text") {
+      return h.text(reply.text);
+    } else if (reply.type === "at") {
+      return h.at(reply.text);
+    } else if (reply.type === "audio") {
+      return h.audio(reply.text);
+    } else if (reply.type === "video") {
+      return h.video(reply.text);
+    }
+    return h.text(String(reply.text));
+  }
+  __name(formatReply, "formatReply");
+  async function addKeywordReply(session, filePath, keyword, options) {
+    let data = {};
+    if (fs.existsSync(filePath)) {
+      try {
+        data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+      } catch (e) {
+        data = {};
+      }
+    }
+    if (config.Treat_all_as_lowercase) keyword = keyword.toLowerCase();
+    const key = options.regex ? `regex:${keyword}` : keyword;
+    if (!data[key]) data[key] = [];
+    if (data[key].length > 0 && config.HandleDuplicateKeywords === "3") {
+      return `关键词 "${keyword}" 已存在，请先删除`;
+    }
+    if (config.HandleDuplicateKeywords === "1") data[key] = [];
+    if (config.AlwayPrompt === "2" || config.AlwayPrompt === "3") {
+      await session.send(config.Prompt);
+    }
+    const replies = [];
+    if (config.MatchPatternForExit === "1") {
+      const timeout = config.addKeywordTime * 6e4;
+      const reply = await session.prompt(timeout);
+      if (!reply) return "输入超时";
+      if (reply.includes(config.KeywordOfEsc)) return "已取消";
+      const parsed = await parseReplyContent(reply, root, session, options);
+      replies.push(parsed);
+    } else {
+      while (true) {
+        if (config.AlwayPrompt === "3") await session.send(config.Prompt);
+        const timeout = config.addKeywordTime * 6e4;
+        const reply = await session.prompt(timeout);
+        if (!reply) return "输入超时";
+        if (reply.includes(config.KeywordOfEsc)) return "已取消";
+        if (config.MatchPatternForExit === "2" && reply === config.KeywordOfEnd) break;
+        if (config.MatchPatternForExit === "3" && reply.includes(config.KeywordOfEnd)) break;
+        if (config.MatchPatternForExit === "4" && (reply === config.KeywordOfEnd || reply.includes(config.KeywordOfEnd))) break;
+        const parsed = await parseReplyContent(reply, root, session, options);
+        replies.push(...parsed);
+      }
+    }
+    data[key].push(replies);
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    return `关键词 "${keyword}" 的回复已添加`;
+  }
+  __name(addKeywordReply, "addKeywordReply");
+  async function deleteKeywordReply(session, filePath, keyword, specifiedIndex) {
+    if (!fs.existsSync(filePath)) return `关键词 "${keyword}" 不存在`;
+    let data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const searchKey = config.Treat_all_as_lowercase ? keyword.toLowerCase() : keyword;
+    let foundKey = null;
+    for (const k in data) {
+      const checkKey = config.Treat_all_as_lowercase ? k.toLowerCase() : k;
+      const realKey = checkKey.startsWith("regex:") ? checkKey.slice(6) : checkKey;
+      if (realKey === searchKey) {
+        foundKey = k;
+        break;
+      }
+    }
+    if (!foundKey) return `关键词 "${keyword}" 不存在`;
+    const replies = data[foundKey];
+    if (config.Delete_Branch_Only && replies.length > 1) {
+      if (!specifiedIndex) {
+        return `该关键词有 ${replies.length} 个回复，请使用 -q 指定删除序号（1-${replies.length}）`;
+      }
+      const idx = parseInt(specifiedIndex) - 1;
+      if (idx < 0 || idx >= replies.length) return "序号无效";
+      replies.splice(idx, 1);
+      if (replies.length === 0) delete data[foundKey];
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+      return `已删除 "${keyword}" 的第 ${specifiedIndex} 个回复`;
+    } else {
+      delete data[foundKey];
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+      return `关键词 "${keyword}" 已删除`;
+    }
+  }
+  __name(deleteKeywordReply, "deleteKeywordReply");
+  async function getTestChannels(session) {
+    const records = await ctx.database.get("qxgl_satori_auth", { platform: session.platform });
+    if (records.length > 0 && records[0].testChannels) {
+      return records[0].testChannels;
+    }
+    return [];
+  }
+  __name(getTestChannels, "getTestChannels");
+  async function setTestChannels(session, channels) {
+    await ctx.database.set(
+      "qxgl_satori_auth",
+      { platform: session.platform },
+      { testChannels: channels }
+    );
+  }
+  __name(setTestChannels, "setTestChannels");
+  ctx.before("command", (session, command) => {
+    const whiteList = [
+      "qxgl-satori.群授权",
+      "qxgl-satori.私聊授权",
+      "qxgl-satori.取消授权",
+      "qxgl-satori.更换授权",
+      "qxgl-satori.到期时间",
+      "qxgl-satori.查询到期",
+      "qxgl-satori.全局延期",
+      "qxgl-satori.全局减少",
+      "qxgl-satori.列出已记录群",
+      "qxgl-satori.更新名称"
+    ];
+    if (whiteList.includes(command.name)) {
+      session.skipAuthCheck = true;
+    }
+    return true;
+  }, true);
+  ctx.middleware(async (session, next) => {
+    if (!session.channelId) return next();
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: session.channelId
+    });
+    if (!record) {
+      const channelName = await updateChannelName(session);
+      await ctx.database.create("qxgl_satori_auth", {
+        platform: session.platform,
+        channelId: session.channelId,
+        expiryDate: config.enableAuthSystem ? null : /* @__PURE__ */ new Date("2099-12-31"),
+        isblockedchannel: false,
+        authorizer: "",
+        channelName,
+        updateDate: /* @__PURE__ */ new Date(),
+        testChannels: []
+      });
+      logInfo(`自动记录新群聊: ${session.channelId}`);
+    }
+    return next();
+  }, true);
+  ctx.middleware(async (session, next) => {
+    if (session.skipAuthCheck) return next();
+    if (!config.enableAuthSystem) return next();
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: session.channelId
+    });
+    if (record?.expiryDate) {
+      const expiry = new Date(record.expiryDate);
+      const now = /* @__PURE__ */ new Date();
+      if (now > expiry) {
+        if (config.autoLeaveOnExpiry && session.platform === "onebot") {
+          await session.bot?.leaveGroup?.(session.channelId);
+        }
+        await ctx.database.set(
+          "qxgl_satori_auth",
+          { platform: session.platform, channelId: session.channelId },
+          { isblockedchannel: true }
+        );
+        return;
+      }
+    }
+    if (record?.isblockedchannel) return;
+    return next();
+  });
+  ctx.command(`${pluginName}/群授权 <channelId> <months> [authorizer]`, "群授权", { authority: config.commandAuthority }).action(async ({ session }, channelId, months, authorizer) => {
+    return await authorizeGroup(session, channelId, months, authorizer);
+  });
+  ctx.command(`${pluginName}/私聊授权 <userId> <months> [authorizer]`, "私聊授权", { authority: config.commandAuthority }).action(async ({ session }, userId, months, authorizer) => {
+    return await authorizePrivate(session, userId, months, authorizer);
+  });
+  ctx.command(`${pluginName}/取消授权 <targetId>`, "取消授权", { authority: config.commandAuthority }).action(async ({ session }, targetId) => {
+    return await cancelAuthorization(session, targetId);
+  });
+  ctx.command(`${pluginName}/更换授权 <sourceId> <targetId>`, "更换授权", { authority: config.commandAuthority }).action(async ({ session }, sourceId, targetId) => {
+    return await changeAuthorization(session, sourceId, targetId);
+  });
+  ctx.command(`${pluginName}/到期时间`, "查询本群/私聊到期时间", { authority: 0 }).action(async ({ session }) => {
+    return await checkExpiryTime(session);
+  });
+  ctx.command(`${pluginName}/查询到期 [targetId]`, "查询指定群/私聊到期时间", { authority: config.commandAuthority }).action(async ({ session }, targetId) => {
+    return await queryExpiryTime(session, targetId);
+  });
+  ctx.command(`${pluginName}/全局延期 <days>`, "为所有群统一延期", { authority: config.commandAuthority }).action(async ({ session }, days) => {
+    return await globalDelayExpiry(session, days);
+  });
+  ctx.command(`${pluginName}/全局减少 <days>`, "为所有群统一减少", { authority: config.commandAuthority }).action(async ({ session }, days) => {
+    return await globalReduceExpiry(session, days);
+  });
+  ctx.command(`${pluginName}/列出已记录群`, "列出所有已记录的群", { authority: config.commandAuthority }).action(async ({ session }) => {
+    const records = await ctx.database.get("qxgl_satori_auth");
+    const groups = records.filter((r) => !r.channelId.startsWith("private:"));
+    if (!groups.length) return "暂无群聊记录";
+    return groups.map(
+      (r) => `群名：${r.channelName}
+群号：${r.channelId}
+到期：${formatDate(r.expiryDate)}
+开启人：${r.authorizer || "蒙面人"}
+更新：${formatDate(r.updateDate)}`
+    ).join("\n\n");
+  });
+  ctx.command(`${pluginName}/更新名称`, "刷新所有群名称缓存", { authority: config.commandAuthority }).action(async ({ session }) => {
+    const records = await ctx.database.get("qxgl_satori_auth");
+    let count = 0;
+    for (const record of records) {
+      if (record.channelId.startsWith("private:")) continue;
+      const name = await updateChannelName({ ...session, channelId: record.channelId });
+      await ctx.database.set(
+        "qxgl_satori_auth",
+        { platform: record.platform, channelId: record.channelId },
+        { channelName: name }
+      );
+      count++;
+    }
+    return `已更新 ${count} 个群聊名称`;
+  });
+  ctx.command(`${pluginName}/添加 <keyword>`, "添加关键词", { authority: config.commandAuthority }).option("regex", "-x 使用正则匹配").option("forward", "-f <type> 指定回复方式(1-4)").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "添加")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    const filePath = path.join(root, `${session.platform}_${session.channelId}.json`);
+    return await addKeywordReply(session, filePath, keyword, { ...options, global: false });
+  });
+  ctx.command(`${pluginName}/全局添加 <keyword>`, "添加全局关键词", { authority: config.commandAuthority }).option("regex", "-x 使用正则匹配").option("forward", "-f <type> 指定回复方式(1-4)").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "全局添加")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    return await addKeywordReply(session, globalFile, keyword, { ...options, global: true });
+  });
+  ctx.command(`${pluginName}/删除 <keyword>`, "删除关键词", { authority: config.commandAuthority }).option("question", "-q <index> 指定删除序号").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "删除")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    const filePath = path.join(root, `${session.platform}_${session.channelId}.json`);
+    return await deleteKeywordReply(session, filePath, keyword, options.question);
+  });
+  ctx.command(`${pluginName}/全局删除 <keyword>`, "删除全局关键词", { authority: config.commandAuthority }).option("question", "-q <index> 指定删除序号").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "全局删除")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    return await deleteKeywordReply(session, globalFile, keyword, options.question);
+  });
+  ctx.command(`${pluginName}/修改 <keyword>`, "修改关键词回复", { authority: config.commandAuthority }).option("question", "-q <index> 指定回复序号").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "修改")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    const filePath = path.join(root, `${session.platform}_${session.channelId}.json`);
+    if (!fs.existsSync(filePath)) return "未找到数据";
+    let data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const key = config.Treat_all_as_lowercase ? keyword.toLowerCase() : keyword;
+    if (!data[key]) return `关键词 "${keyword}" 不存在`;
+    const idx = (parseInt(options.question) || 1) - 1;
+    if (idx < 0 || idx >= data[key].length) return "序号无效";
+    let current = "";
+    for (const item of data[key][idx]) {
+      current += await formatReply(item, session);
+    }
+    await session.send(`正在修改【${keyword}】的第 ${idx + 1} 条回复：
+${current}`);
+    await session.send(`请一次性输入新内容（${config.KeywordOfEsc} 取消）：`);
+    const reply = await session.prompt(config.addKeywordTime * 6e4);
+    if (!reply || reply.includes(config.KeywordOfEsc)) return "已取消";
+    data[key][idx] = await parseReplyContent(reply, root, session, { global: false });
+    fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+    return `已修改 "${keyword}" 的第 ${idx + 1} 条回复`;
+  });
+  ctx.command(`${pluginName}/全局修改 <keyword>`, "修改全局关键词", { authority: config.commandAuthority }).option("question", "-q <index> 指定回复序号").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "全局修改")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    if (!fs.existsSync(globalFile)) return "未找到全局数据";
+    let data = JSON.parse(fs.readFileSync(globalFile, "utf-8"));
+    const key = config.Treat_all_as_lowercase ? keyword.toLowerCase() : keyword;
+    if (!data[key]) return `全局关键词 "${keyword}" 不存在`;
+    const idx = (parseInt(options.question) || 1) - 1;
+    if (idx < 0 || idx >= data[key].length) return "序号无效";
+    let current = "";
+    for (const item of data[key][idx]) {
+      current += await formatReply(item, session);
+    }
+    await session.send(`正在修改全局【${keyword}】的第 ${idx + 1} 条回复：
+${current}`);
+    await session.send(`请一次性输入新内容（${config.KeywordOfEsc} 取消）：`);
+    const reply = await session.prompt(config.addKeywordTime * 6e4);
+    if (!reply || reply.includes(config.KeywordOfEsc)) return "已取消";
+    data[key][idx] = await parseReplyContent(reply, root, session, { global: true });
+    fs.writeFileSync(globalFile, JSON.stringify(data, null, 2));
+    return `已修改全局 "${keyword}" 的第 ${idx + 1} 条回复`;
+  });
+  ctx.command(`${pluginName}/查找关键词 <keyword>`, "查找关键词", { authority: config.commandAuthority }).action(async ({ session }, keyword) => {
+    if (!hasPermission(session, "查找关键词")) return "权限不足";
+    if (!keyword) return "请提供关键词";
+    const files = [];
+    if (config.Search_Range === "1" || config.Search_Range === "3") {
+      files.push(path.join(root, `${session.platform}_${session.channelId}.json`));
+    }
+    if (config.Search_Range === "2" || config.Search_Range === "3") {
+      files.push(globalFile);
+      const allFiles = fs.readdirSync(root).filter((f) => f.endsWith(".json") && f !== "test.json" && f !== "global.json");
+      files.push(...allFiles.map((f) => path.join(root, f)));
+    }
+    const results = [];
+    for (const file of [...new Set(files)]) {
+      if (!fs.existsSync(file)) continue;
+      const data = JSON.parse(fs.readFileSync(file, "utf-8"));
+      for (const key in data) {
+        const checkKey = config.Treat_all_as_lowercase ? key.toLowerCase() : key;
+        const searchKey = config.Treat_all_as_lowercase ? keyword.toLowerCase() : keyword;
+        if (checkKey.includes(searchKey)) {
+          const channelId = path.basename(file, ".json").replace(`${session.platform}_`, "");
+          const content = data[key].map(
+            (group, i) => `回复${i + 1}: ${group.map((g) => g.type === "text" ? g.text : `[${g.type}]`).join(", ")}`
+          ).join("\n");
+          if (config.Find_Return_Preset === "1") results.push(`关键词：${key}
+${content}`);
+          else if (config.Find_Return_Preset === "2") results.push(`位置：${channelId}`);
+          else results.push(`位置：${channelId}
+关键词：${key}
+${content}`);
+          if (config.Return_Limit === "2") break;
+        }
+      }
+    }
+    if (!results.length) return `未找到 "${keyword}"`;
+    return results.join("\n\n");
+  });
+  ctx.command(`${pluginName}/查看关键词列表`, "查看关键词列表", { authority: config.commandAuthority }).action(async ({ session }) => {
+    if (!hasPermission(session, "查看关键词列表")) return "权限不足";
+    const filePath = path.join(root, `${session.platform}_${session.channelId}.json`);
+    const globalData = fs.existsSync(globalFile) ? JSON.parse(fs.readFileSync(globalFile, "utf-8")) : {};
+    const localData = fs.existsSync(filePath) ? JSON.parse(fs.readFileSync(filePath, "utf-8")) : {};
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(globalData), ...Object.keys(localData)])];
+    if (!keys.length) return "暂无关键词";
+    return `关键词列表（共${keys.length}个）：
+` + keys.join("\n");
+  });
+  ctx.command(`${pluginName}/测试授权 <...targets>`, "将群/私聊加入测试名单", { authority: config.commandAuthority }).action(async ({ session }, ...targets) => {
+    if (!targets.length) return "请提供至少一个目标ID";
+    const channels = await getTestChannels(session);
+    const set = new Set(channels);
+    const added = [];
+    for (const t of targets) {
+      const cid = t.startsWith("private:") ? t : t;
+      if (!set.has(cid)) {
+        set.add(cid);
+        added.push(t);
+      }
+    }
+    if (added.length) await setTestChannels(session, Array.from(set));
+    return added.length ? `已加入测试名单：${added.join("、")}` : "指定目标已在测试名单中";
+  });
+  ctx.command(`${pluginName}/取消测试授权 <...targets>`, "将群/私聊移出测试名单", { authority: config.commandAuthority }).action(async ({ session }, ...targets) => {
+    if (!targets.length) return "请提供至少一个目标ID";
+    const channels = await getTestChannels(session);
+    const set = new Set(channels);
+    const removed = [];
+    for (const t of targets) {
+      const cid = t.startsWith("private:") ? t : t;
+      if (set.has(cid)) {
+        set.delete(cid);
+        removed.push(t);
+      }
+    }
+    if (removed.length) await setTestChannels(session, Array.from(set));
+    return removed.length ? `已移出测试名单：${removed.join("、")}` : "指定目标不在测试名单中";
+  });
+  ctx.command(`${pluginName}/测试同步`, "全局问答复制到测试环境", { authority: config.commandAuthority }).action(async ({ session }) => {
+    if (!fs.existsSync(globalFile)) return "全局问答文件不存在";
+    fs.copyFileSync(globalFile, testFile);
+    const data = JSON.parse(fs.readFileSync(testFile, "utf-8"));
+    return `测试同步完成，共 ${Object.keys(data).length} 条问答已复制`;
+  });
+  ctx.command(`${pluginName}/测试发布`, "测试问答发布到全局", { authority: config.commandAuthority }).alias("测试转正").alias("全局发布").action(async ({ session }) => {
+    if (!fs.existsSync(testFile)) return "测试问答文件不存在";
+    const backupFile = path.join(root, "global.json.pub.bak");
+    if (fs.existsSync(globalFile)) fs.copyFileSync(globalFile, backupFile);
+    fs.copyFileSync(testFile, globalFile);
+    const data = JSON.parse(fs.readFileSync(globalFile, "utf-8"));
+    return `测试发布完成，共 ${Object.keys(data).length} 条问答已发布，原全局已备份`;
+  });
+  ctx.command(`${pluginName}/测试添加 <keyword>`, "添加测试关键词", { authority: config.commandAuthority }).option("regex", "-x 使用正则匹配").option("forward", "-f <type> 指定回复方式(1-4)").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "测试添加")) return "权限不足";
+    return await addKeywordReply(session, testFile, keyword, { ...options, global: false });
+  });
+  ctx.command(`${pluginName}/测试删除 <keyword>`, "删除测试关键词", { authority: config.commandAuthority }).option("question", "-q <index> 指定删除序号").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "测试删除")) return "权限不足";
+    return await deleteKeywordReply(session, testFile, keyword, options.question);
+  });
+  ctx.command(`${pluginName}/测试修改 <keyword>`, "修改测试关键词", { authority: config.commandAuthority }).option("question", "-q <index> 指定回复序号").action(async ({ session, options }, keyword) => {
+    if (!hasPermission(session, "测试修改")) return "权限不足";
+    if (!fs.existsSync(testFile)) return "测试文件不存在";
+    return "测试修改功能待完善";
+  });
+  ctx.middleware(async (session, next) => {
+    if (!session.content) return next();
+    let content = session.content;
+    if (config.Treat_all_as_lowercase) content = content.toLowerCase();
+    const testChannels = await getTestChannels(session);
+    const isTest = testChannels.includes(session.channelId) || testChannels.includes(`private:${session.userId}`);
+    const files = [];
+    if (isTest) {
+      files.push(testFile);
+    } else {
+      if (config.Search_Range === "3" || config.Search_Range === "2") files.push(globalFile);
+      if (config.Search_Range === "1" || config.Search_Range === "3") {
+        files.push(path.join(root, `${session.platform}_${session.channelId}.json`));
+      }
+    }
+    for (const file of files) {
+      if (!fs.existsSync(file)) continue;
+      const data = JSON.parse(fs.readFileSync(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 replies = data[key];
+        if (key.startsWith("regex:")) {
+          const pattern = key.slice(6);
+          isMatch = new RegExp(pattern).test(content);
+        } else {
+          isMatch = content === key;
+        }
+        if (isMatch) {
+          const limitKey = config.Type_of_restriction === "2" ? `${key}:${session.channelId}` : key;
+          const now = Date.now();
+          if (config.Frequency_limitation > 0 && lastTriggerTimes[limitKey] && now - lastTriggerTimes[limitKey] < config.Frequency_limitation * 1e3) {
+            return;
+          }
+          lastTriggerTimes[limitKey] = now;
+          const group = replies[Math.floor(Math.random() * replies.length)];
+          const replyway = group[0]?.replyway || config.MultisegmentAdditionRecoveryEffect;
+          if (replyway === "1") {
+            for (const item of group) {
+              await session.send(await formatReply(item, session));
+            }
+          } else if (replyway === "2") {
+            let combined = "";
+            for (const item of group) combined += await formatReply(item, session);
+            await session.send(combined);
+          } else if (replyway === "3" || replyway === "4") {
+            const figure = h("figure");
+            for (const item of group) {
+              const formatted = await formatReply(item, session);
+              figure.children.push(replyway === "4" ? h("message", {}, formatted) : formatted);
+            }
+            await session.send(figure);
+          }
+          return;
+        }
+      }
+    }
+    return next();
+  });
+  ctx.on("guild-member", async (session) => {
+    if (!config.autoLeaveOnMute) return;
+    if (session.subtype !== "ban") return;
+    if (session.selfId !== session.userId) return;
+    const [record] = await ctx.database.get("qxgl_satori_auth", {
+      platform: session.platform,
+      channelId: session.guildId
+    });
+    if (record && session.bot?.leaveGroup) {
+      await session.bot.leaveGroup(session.guildId);
+    }
+  });
+}
+__name(apply, "apply");
+exports.apply = apply;
+exports.Config = Config;
+exports.name = pluginName;
+exports.usage = usage;
+exports.inject = inject;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "koishi-plugin-qxgl-satori",
+  "description": "开发中",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "chatbot",
+    "koishi",
+    "plugin"
+  ],
+  "peerDependencies": {
+    "koishi": "4.18.10"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-qxgl-satori
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-qxgl-satori?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-qxgl-satori)
+
+开发中