koishi-plugin-group-verification 1.0.16 → 1.0.17

package/lib/index.d.ts

@@ -43,4 +43,56 @@ export interface Config {
 }
 export declare const Config: Schema<Config>;
 export declare const inject: string[];
+/**
+ * 将输入字符串按照空格和逗号分隔，支持双引号包裹以保留空格/逗号。
+ * 返回解码后的令牌数组。
+ */
+export interface TokenizeResult {
+    tokens: string[];
+    seps: string[];
+    error?: string;
+}
+export declare function tokenize(input: string): TokenizeResult;
+export interface ParsedArgs {
+    keywords: string[];
+    flags: {
+        groupId?: string;
+        method?: string;
+        threshold?: string;
+        message?: string;
+        enableMessage?: boolean;
+        disableMessage?: boolean;
+        query?: boolean;
+        remove?: boolean;
+    };
+    error?: string;
+}
+/**
+ * 合并提醒消息设置
+ *
+ * existingConfig - 数据库中已存在的配置记录（可能为 null）
+ * cleanedOptions - 从 flags/options 合并出来的对象，包含 message/enableMessage/disableMessage
+ * hasRealMessageParam - 是否由用户通过 -msg 指定了具体内容
+ * hasRealEnableMessageParam - 是否仅给了 bare -msg
+ * hasRealDisableMessageParam - 是否给了 -nomsg
+ * logger - 用于记录调试信息的日志器
+ *
+ * 返回最终的 reminderEnabled 和 reminderMessage。
+ * 对于 -nomsg 不会清除已保存的 message，便于后续再次启用时恢复。
+ */
+export declare function mergeReminder(existingConfig: any | null, cleanedOptions: {
+    message?: string;
+    enableMessage?: boolean;
+    disableMessage?: boolean;
+}, hasRealMessageParam: boolean, hasRealEnableMessageParam: boolean, hasRealDisableMessageParam: boolean, logger: any): {
+    reminderEnabled: boolean;
+    reminderMessage: string;
+};
+/**
+ * 解析 gvc 配置命令的原始参数。
+ *
+ * 返回关键词数组和各类 flag 的值，未出现的 flag 保持 undefined。
+ * 若检测到格式错误（如纯空格分隔关键词），返回 error 字段。
+ */
+export declare function parseConfigArgs(raw: string): ParsedArgs;
 export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -23,23 +23,230 @@ __export(src_exports, {
   Config: () => Config,
   apply: () => apply,
   inject: () => inject,
-  name: () => name
+  mergeReminder: () => mergeReminder,
+  name: () => name,
+  parseConfigArgs: () => parseConfigArgs,
+  tokenize: () => tokenize
 });
 module.exports = __toCommonJS(src_exports);
 var import_koishi = require("koishi");
 var name = "group-verification";
 var Config = import_koishi.Schema.object({
-  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板").default(
-    `用户 {user}({id}) 申请加入群 {gname}({group})
-申请理由：{question}
-答对情况：{answer}
-阈值要求：{threshold}
-请管理员使用 #同意 或 #拒绝 来处理此申请`
-  ),
-  enableStrictGroupCheck: import_koishi.Schema.boolean().description("是否启用严格的群号检查（验证机器人是否在群中）").default(true),
+  defaultReminderMessage: import_koishi.Schema.string().description("默认提醒消息模板").default("{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}"),
+  enableStrictGroupCheck: import_koishi.Schema.boolean().description("是否启用严格的群号检查（检查群号长度）").default(false),
   logLevel: import_koishi.Schema.union(["debug", "info", "warn", "error"]).description("日志级别").default("info")
 }).description("群组验证插件配置");
 var inject = ["database"];
+var ESC_QUOTE = "\0";
+var ESC_BACKSLASH = "
";
+function tokenize(input) {
+  const tokens = [];
+  const seps = [];
+  let cur = "";
+  let lastSep = "";
+  let i = 0;
+  const flush = /* @__PURE__ */ __name(() => {
+    if (cur !== "") {
+      tokens.push(cur);
+      seps.push(lastSep);
+      cur = "";
+      lastSep = "";
+    }
+  }, "flush");
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === " " || ch === ",") {
+      lastSep = ch;
+      flush();
+      i++;
+      continue;
+    }
+    if (ch === '"') {
+      const prev = i > 0 ? input[i - 1] : "";
+      if (i === 0 || prev === " " || prev === ",") {
+        i++;
+        let content = "";
+        let closed = false;
+        while (i < input.length) {
+          const c = input[i];
+          if (c === "\\") {
+            if (i + 1 < input.length) {
+              const nxt = input[i + 1];
+              if (nxt === '"') {
+                content += ESC_QUOTE;
+                i += 2;
+                continue;
+              }
+              if (nxt === "\\") {
+                content += ESC_BACKSLASH;
+                i += 2;
+                continue;
+              }
+            }
+            content += "\\";
+            i++;
+          } else if (c === '"') {
+            closed = true;
+            i++;
+            break;
+          } else {
+            content += c;
+            i++;
+          }
+        }
+        if (!closed) {
+          return { tokens, seps, error: "引号未闭合" };
+        }
+        tokens.push(content);
+        continue;
+      } else {
+        cur += ch;
+        i++;
+        continue;
+      }
+    }
+    if (ch === "\\") {
+      if (i + 1 < input.length) {
+        const nxt = input[i + 1];
+        if (nxt === '"') {
+          cur += ESC_QUOTE;
+          i += 2;
+          continue;
+        }
+        if (nxt === "\\") {
+          cur += ESC_BACKSLASH;
+          i += 2;
+          continue;
+        }
+      }
+      cur += ch;
+      i++;
+      continue;
+    }
+    cur += ch;
+    i++;
+  }
+  flush();
+  return { tokens, seps };
+}
+__name(tokenize, "tokenize");
+function validateKeywordFormat(raw) {
+  if (raw.includes(",") || raw.includes('"')) {
+    return true;
+  }
+  if (raw.includes(" ")) {
+    return false;
+  }
+  return true;
+}
+__name(validateKeywordFormat, "validateKeywordFormat");
+function mergeReminder(existingConfig, cleanedOptions, hasRealMessageParam, hasRealEnableMessageParam, hasRealDisableMessageParam, logger) {
+  let reminderEnabled = true;
+  let reminderMessage = "{user}({id}) 申请加入群 {gname}({group})\n申请理由：{question}\n匹配情况：{answer}/{threshold}";
+  if (existingConfig) {
+    reminderEnabled = existingConfig.reminderEnabled;
+    reminderMessage = existingConfig.reminderMessage || reminderMessage;
+  }
+  if (hasRealDisableMessageParam) {
+    reminderEnabled = false;
+    logger.info("禁用提醒消息功能 (保留现有内容)");
+  } else if (hasRealEnableMessageParam) {
+    reminderEnabled = true;
+    logger.info(`启用提醒消息（保留原消息）: ${reminderMessage.substring(0, 50)}...`);
+  } else if (hasRealMessageParam) {
+    reminderEnabled = true;
+    if (cleanedOptions.message !== void 0) {
+      reminderMessage = cleanedOptions.message.replace(/\\n/g, "\n");
+      logger.info(`设置自定义提醒消息: ${reminderMessage.substring(0, 50)}...`);
+    }
+  }
+  return { reminderEnabled, reminderMessage };
+}
+__name(mergeReminder, "mergeReminder");
+function parseConfigArgs(raw) {
+  const res = tokenize(raw);
+  if (res.error) {
+    return { keywords: [], flags: {}, error: res.error };
+  }
+  let tokens = res.tokens;
+  const seps = res.seps;
+  const flags = {};
+  const keywords = [];
+  let error;
+  const isFlag = /* @__PURE__ */ __name((tok) => /^-(?:i|m|t|msg|nomsg|\?|r)$/.test(tok), "isFlag");
+  for (const tok of tokens) {
+    if (tok.includes('"')) {
+      error = "存在未转义的引号";
+      return { keywords: [], flags, error };
+    }
+  }
+  tokens = tokens.map(
+    (t) => t.replace(new RegExp(ESC_QUOTE, "g"), '"').replace(new RegExp(ESC_BACKSLASH, "g"), "\\")
+  );
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (tok === "-i") {
+      if (tokens[i + 1] && !isFlag(tokens[i + 1])) {
+        flags.groupId = tokens[++i];
+      } else {
+        return { keywords: [], flags, error: "参数 -i 需要指定群号" };
+      }
+    } else if (tok === "-m") {
+      if (tokens[i + 1] && !isFlag(tokens[i + 1])) {
+        flags.method = tokens[++i];
+      } else {
+        return { keywords: [], flags, error: "参数 -m 需要指定审核方式" };
+      }
+    } else if (tok === "-t") {
+      if (tokens[i + 1] && !isFlag(tokens[i + 1])) {
+        flags.threshold = tokens[++i];
+      } else {
+        return { keywords: [], flags, error: "参数 -t 需要指定阈值" };
+      }
+    } else if (tok === "-msg") {
+      const clusters = [];
+      let j = i + 1;
+      while (j < tokens.length && !isFlag(tokens[j])) {
+        const cluster = [tokens[j]];
+        while (j < tokens.length - 1 && seps[j] === ",") {
+          j++;
+          cluster.push(tokens[j]);
+        }
+        clusters.push(cluster);
+        j++;
+      }
+      i = j - 1;
+      if (clusters.length === 0) {
+        flags.enableMessage = true;
+      } else {
+        const msgCluster = clusters[0];
+        flags.message = msgCluster.join(",");
+        if (clusters.length > 1) {
+          for (let k = 1; k < clusters.length; k++) {
+            const kws = clusters[k];
+            for (const kw of kws) {
+              keywords.push(kw);
+            }
+          }
+        }
+      }
+    } else if (tok === "-nomsg") {
+      flags.disableMessage = true;
+    } else if (tok === "-?") {
+      flags.query = true;
+    } else if (tok === "-r") {
+      flags.remove = true;
+    } else {
+      keywords.push(tok);
+    }
+  }
+  const keywordSection = raw.split(/(?:^|\s+)-(?:i|m|t|msg|nomsg|\?|r)\b/)[0].trim();
+  if (keywordSection && !validateKeywordFormat(keywordSection)) {
+    error = '关键词应使用逗号分隔或引号框起（如：k1,k2,k3 或 "k1","k2" 或 "k1,k2",k3）';
+  }
+  return { keywords, flags, error };
+}
+__name(parseConfigArgs, "parseConfigArgs");
 function apply(ctx, config) {
   ctx.model.extend("group_verification_config", {
     id: "unsigned",
@@ -61,6 +268,7 @@ function apply(ctx, config) {
   const logger = ctx.logger("group-verification");
   logger.info("群组验证插件已启动");
   logger.info(`默认提醒消息: ${config.defaultReminderMessage}`);
+  logger.info(`严格群号检查: ${config.enableStrictGroupCheck ? "启用" : "禁用"}`);
   logger.info(`日志级别: ${config.logLevel}`);
   ctx.model.extend("group_verification_stats", {
     id: "unsigned",
@@ -268,42 +476,62 @@ ${debugInfo}`];
     "gvc"
   ).option("groupId", "-i <groupId> 指定群号").option("method", "-m <method> 审核方式 (0-3)").option("threshold", "-t <threshold> 阈值参数").option("message", "-msg [message] 自定义提醒消息").option("disableMessage", "-nomsg 禁用提醒消息").option("query", "-? 查询当前配置").option("remove", "-r 删除配置").action(async ({ session, options }, keywords) => {
     logger.info(`=== 命令解析调试 ===`);
-    logger.info(`原始keywords: "${keywords}" (类型: ${typeof keywords})`);
-    logger.info(`options对象: ${JSON.stringify(options, null, 2)}`);
     logger.info(`session内容: guildId=${session.guildId}, userId=${session.userId}`);
-    logger.info(`==================`);
-    const targetGroupId = options.groupId || session.guildId;
+    const rawInput = session.content.split(/\s+/).slice(1).join(" ");
+    logger.info(`原始命令参数: "${rawInput}"`);
+    const parsed = parseConfigArgs(rawInput);
+    const { keywords: parsedKeywords, flags, error: parseError } = parsed;
+    if (parseError) {
+      return parseError;
+    }
+    logger.info(`解析结果 flags=${JSON.stringify(flags)}, keywords=[${parsedKeywords.join(", ")}]`);
+    const cleanedOptions = {
+      groupId: flags.groupId || options.groupId,
+      method: flags.method || (options.method === "" ? void 0 : options.method),
+      threshold: flags.threshold || options.threshold,
+      message: flags.message !== void 0 ? flags.message : options.message,
+      enableMessage: flags.enableMessage,
+      // 新增：-msg 裸调用标记
+      disableMessage: flags.disableMessage || options.disableMessage,
+      query: flags.query || options.query,
+      remove: flags.remove || options.remove
+    };
+    logger.info(`合并后options: ${JSON.stringify(cleanedOptions, null, 2)}`);
+    if ((cleanedOptions.query || cleanedOptions.remove) && (parsedKeywords.length > 0 || cleanedOptions.method !== void 0 || cleanedOptions.threshold !== void 0 || cleanedOptions.message !== void 0 || cleanedOptions.enableMessage || cleanedOptions.disableMessage || cleanedOptions.groupId !== void 0)) {
+      return "参数冲突：-? 或 -r 不能与其他参数或关键词一起使用";
+    }
+    const hasRealMessageParam = cleanedOptions.message !== void 0;
+    const hasRealEnableMessageParam = cleanedOptions.enableMessage === true;
+    const hasRealDisableMessageParam = cleanedOptions.disableMessage !== void 0;
+    const targetGroupId = cleanedOptions.groupId || session.guildId;
     if (targetGroupId) {
-      try {
-        if (config.enableStrictGroupCheck) {
-          await session.bot.getGuild(targetGroupId);
+      if (config.enableStrictGroupCheck && cleanedOptions.groupId) {
+        if (targetGroupId.length < 5 || targetGroupId.length > 15) {
+          return `群号 ${targetGroupId} 格式不合法（长度应在5-15位之间）`;
         }
+      }
+      try {
+        await session.bot.getGuild(targetGroupId);
         const [hasPermission, errorMsg] = await checkPermission(session, targetGroupId);
         if (!hasPermission) {
           return errorMsg || "权限不足";
         }
       } catch (error) {
-        if (config.enableStrictGroupCheck) {
-          return `群号 ${targetGroupId} 无效或机器人不在该群中`;
-        } else {
-          const [hasPermission, errorMsg] = await checkPermission(session, targetGroupId);
-          if (!hasPermission) {
-            return errorMsg || "权限不足";
-          }
-        }
+        return `群号 ${targetGroupId} 无效或机器人不在该群中`;
       }
     } else {
       return "请在群聊中使用此命令或指定群号(-i参数)";
     }
-    if (options.message !== void 0 && options.disableMessage) {
+    if ((hasRealMessageParam || hasRealEnableMessageParam) && hasRealDisableMessageParam) {
       return "参数冲突：不能同时使用 -msg 和 -nomsg";
     }
     const usedOptions = [];
-    if (options.method !== void 0) usedOptions.push("-m");
-    if (options.threshold !== void 0) usedOptions.push("-t");
-    if (options.groupId !== void 0) usedOptions.push("-i");
-    if (options.message !== void 0) usedOptions.push("-msg");
-    if (options.disableMessage) usedOptions.push("-nomsg");
+    if (cleanedOptions.method !== void 0) usedOptions.push("-m");
+    if (cleanedOptions.threshold !== void 0) usedOptions.push("-t");
+    if (cleanedOptions.groupId !== void 0) usedOptions.push("-i");
+    if (cleanedOptions.message !== void 0) usedOptions.push("-msg");
+    if (cleanedOptions.enableMessage) usedOptions.push("-msg");
+    if (cleanedOptions.disableMessage) usedOptions.push("-nomsg");
     if (usedOptions.length > new Set(usedOptions).size) {
       return `检测到重复参数: ${usedOptions.join(", ")}，将使用最后一次出现的值`;
     }
@@ -313,7 +541,7 @@ ${debugInfo}`];
       groupName = guild.name || groupName;
     } catch (error) {
     }
-    if (options.remove) {
+    if (cleanedOptions.remove) {
       const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
       if (existingConfig2.length > 0) {
         await ctx.database.remove("group_verification_config", { id: existingConfig2[0].id });
@@ -323,7 +551,7 @@ ${debugInfo}`];
         return `群 ${targetGroupId} 无验证配置`;
       }
     }
-    if (options.query) {
+    if (cleanedOptions.query) {
       const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
       if (existingConfig2.length > 0) {
         const config2 = existingConfig2[0];
@@ -367,93 +595,10 @@ ${debugInfo}`];
         return `群 ${targetGroupId} 无验证配置`;
       }
     }
-    let keywordList = [];
-    if (keywords) {
-      logger.info(`开始处理关键词: "${keywords}"`);
-      let processedInput = keywords.trim();
-      let keywordSection = processedInput;
-      let paramSection = "";
-      const paramMatch = processedInput.match(/\s+-(?:m|t|i|msg|nomsg|\?|r)\s+/);
-      if (paramMatch) {
-        const paramIndex = paramMatch.index;
-        keywordSection = processedInput.substring(0, paramIndex).trim();
-        paramSection = processedInput.substring(paramIndex).trim();
-        logger.info(`参数分离: 关键词="${keywordSection}", 参数="${paramSection}"`);
-      }
-      if (options.method !== void 0) {
-        logger.info(`检测到 -m 参数: ${options.method}`);
-      }
-      if (options.threshold !== void 0) {
-        logger.info(`检测到 -t 参数: ${options.threshold}`);
-      }
-      if (typeof paramSection !== "undefined" && paramSection) {
-        logger.info(`手动解析参数部分: "${paramSection}"`);
-        const mMatch = paramSection.match(/-m\s+(\d+)/);
-        if (mMatch && options.method === void 0) {
-          options.method = mMatch[1];
-          logger.info(`手动解析 -m: ${options.method}`);
-        }
-        const tMatch = paramSection.match(/-t\s+(\d+)/);
-        if (tMatch && options.threshold === void 0) {
-          options.threshold = tMatch[1];
-          logger.info(`手动解析 -t: ${options.threshold}`);
-        }
-      }
-      if (keywordSection) {
-        logger.info(`开始处理关键词部分: "${keywordSection}"`);
-        const result = [];
-        let i = 0;
-        while (i < keywordSection.length) {
-          const char = keywordSection[i];
-          if (char === '"') {
-            i++;
-            let content = "";
-            let foundEndQuote = false;
-            while (i < keywordSection.length) {
-              if (keywordSection[i] === '"' && (i === 0 || keywordSection[i - 1] !== "\\")) {
-                foundEndQuote = true;
-                i++;
-                break;
-              } else {
-                content += keywordSection[i];
-                i++;
-              }
-            }
-            let hasNextComma = false;
-            if (i < keywordSection.length && keywordSection[i] === ",") {
-              hasNextComma = true;
-              i++;
-            }
-            result.push(content);
-            logger.info(`引号处理: "${content}", 下一个逗号: ${hasNextComma}`);
-            if (!foundEndQuote) {
-              logger.info("未找到结束引号，前引号作为内容处理");
-            }
-          } else if (char === "," || char === " ") {
-            i++;
-          } else {
-            let content = "";
-            while (i < keywordSection.length && keywordSection[i] !== "," && keywordSection[i] !== " ") {
-              content += keywordSection[i];
-              i++;
-            }
-            if (content) {
-              result.push(content);
-              logger.info(`普通内容处理: "${content}"`);
-            }
-            if (i < keywordSection.length && (keywordSection[i] === "," || keywordSection[i] === " ")) {
-              i++;
-            }
-          }
-        }
-        keywordList = result.filter((item) => item.length > 0);
-        logger.info(`最终处理结果: [${keywordList.map((k) => `"${k}"`).join(", ")}]`);
-      }
-      logger.info(`最终关键词列表: [${keywordList.map((k) => `"${k}"`).join(", ")}]`);
-    }
-    logger.info(`关键词解析结果: [${keywordList.join(", ")}] - 原始输入: "${keywords}"`);
-    if (keywordList.length === 0 && !options.query && !options.remove) {
-      const hasConfigParams = options.method !== void 0 || options.threshold !== void 0 || options.message !== void 0 || options.disableMessage !== void 0;
+    let keywordList = parsedKeywords.slice();
+    logger.info(`关键词解析结果: [${keywordList.join(", ")}] - 原始输入: "${rawInput}"`);
+    if (keywordList.length === 0 && !cleanedOptions.query && !cleanedOptions.remove) {
+      const hasConfigParams = cleanedOptions.method !== void 0 || cleanedOptions.threshold !== void 0 || hasRealMessageParam || hasRealEnableMessageParam || hasRealDisableMessageParam;
       if (!hasConfigParams) {
         return `用法：
 gvc 关键词1,关键词2 -m 1 -t 2    # 创建配置
@@ -463,36 +608,29 @@ gvc -nomsg                       # 禁用提醒消息
 gvc -?                          # 查询配置
 gvc -r                          # 删除配置`;
       }
-      const existingConfig2 = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
-      if (existingConfig2.length === 0) {
+    }
+    let existingConfig = null;
+    const existingConfigs = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
+    if (existingConfigs.length > 0) {
+      existingConfig = existingConfigs[0];
+    }
+    if (keywordList.length === 0 && !cleanedOptions.query && !cleanedOptions.remove) {
+      if (!existingConfig) {
         return "请先提供关键词创建配置，或使用 -? 查询配置，-r 删除配置";
       }
-      keywordList = existingConfig2[0].keywords;
-    }
-    let reminderEnabled = true;
-    let reminderMessage = config.defaultReminderMessage || `用户 {user}({id}) 申请加入群 {gname}({group})
-申请理由：{question}
-答对情况：{answer}
-阈值要求：{threshold}
-请管理员使用 #同意 或 #拒绝 来处理此申请`;
-    if (options.disableMessage) {
-      reminderEnabled = false;
-      reminderMessage = "";
-    } else if (options.message !== void 0) {
-      reminderEnabled = true;
-      if (options.message !== "") {
-        reminderMessage = options.message;
-      }
-    }
-    if (reminderEnabled && reminderMessage) {
-      reminderMessage = reminderMessage.replace(/\\n/g, "\n");
+      keywordList = existingConfig.keywords;
     }
+    const { reminderEnabled, reminderMessage } = mergeReminder(
+      existingConfig,
+      cleanedOptions,
+      hasRealMessageParam,
+      hasRealEnableMessageParam,
+      hasRealDisableMessageParam,
+      logger
+    );
     let reviewMethod = 0;
     let reviewParameters = 0;
-    let existingConfig = null;
-    const configs = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
-    if (configs.length > 0) {
-      existingConfig = configs[0];
+    if (existingConfig) {
       reviewMethod = existingConfig.reviewMethod;
       if (existingConfig.reviewParameters === void 0 || existingConfig.reviewParameters === null || isNaN(existingConfig.reviewParameters)) {
         reviewParameters = 0;
@@ -501,23 +639,18 @@ gvc -r                          # 删除配置`;
         reviewParameters = existingConfig.reviewParameters;
       }
     }
-    if (options.method !== void 0) {
-      const methodNum = parseInt(options.method);
+    if (cleanedOptions.method !== void 0 && cleanedOptions.method !== "") {
+      const methodNum = parseInt(cleanedOptions.method);
       if (isNaN(methodNum) || methodNum < 0 || methodNum > 3) {
         return "审核方式参数错误：0-全部同意, 1-按数量同意, 2-按比例同意, 3-全部拒绝";
       }
       reviewMethod = methodNum;
       logger.info(`审核方式明确指定为: ${reviewMethod}`);
-      if (reviewMethod === 0 || reviewMethod === 3) {
-        reviewParameters = 0;
-      } else if (reviewParameters === 0) {
-        reviewParameters = reviewMethod === 1 ? keywordList.length : 100;
-      }
     } else {
       logger.info(`未指定审核方式，保持原有值: ${reviewMethod}`);
     }
-    if (options.threshold !== void 0) {
-      const thresholdNum = parseInt(options.threshold);
+    if (cleanedOptions.threshold !== void 0) {
+      const thresholdNum = parseInt(cleanedOptions.threshold);
       if (isNaN(thresholdNum)) {
         return "阈值参数必须为数字";
       }
@@ -550,7 +683,6 @@ gvc -r                          # 删除配置`;
         logger.info(`关键词数量未变化(${newKeywordCount})，保持原阈值: ${reviewParameters}`);
       }
     }
-    const existingConfigs = await ctx.database.get("group_verification_config", { groupId: targetGroupId });
     const encodedKeywords = keywordList.map((keyword) => {
       return keyword.replace(/,/g, "[[COMMA]]");
     });
@@ -565,8 +697,8 @@ gvc -r                          # 删除配置`;
       updatedBy: session.username || session.userId,
       updatedAt: /* @__PURE__ */ new Date()
     };
-    if (existingConfigs.length > 0) {
-      await ctx.database.set("group_verification_config", { id: existingConfigs[0].id }, dbData);
+    if (existingConfig) {
+      await ctx.database.set("group_verification_config", { id: existingConfig.id }, dbData);
       logger.info(`更新配置成功 - 审核方式: ${reviewMethod}, 阈值: ${reviewParameters}`);
     } else {
       await ctx.database.create("group_verification_config", {
@@ -580,7 +712,8 @@ gvc -r                          # 删除配置`;
     const decodedKeywords = keywordList;
     let feedbackMessage = `群 ${targetGroupId} 配置已更新:
 `;
-    feedbackMessage += `关键词: ${decodedKeywords.map((k) => `"${k}"`).join(", ")}
+    const displayKeywords = keywordList.map((k) => k.replace(/\[\[COMMA\]\]/g, ","));
+    feedbackMessage += `关键词: ${displayKeywords.map((k) => `"${k}"`).join(", ")}
 `;
     const methodMap = { 0: "全部同意", 1: "按数量", 2: "按比例", 3: "全部拒绝" };
     feedbackMessage += `审核方式: ${methodMap[reviewMethod]}
@@ -827,7 +960,10 @@ gvc -r                          # 删除配置`;
     -i <群号>     指定群号（私聊时必需）
     -m <方式>     审核方式 (0=全部同意, 1=按数量, 2=按比例, 3=全部拒绝)
     -t <阈值>     阈值参数（方式1:0-关键词数, 方式2:0-100）
-    -msg [消息]   自定义提醒消息（支持引号和\\n换行）
+    -msg [消息]   自定义提醒消息（支持引号和\\n换行）；若不跟内容则仅启用/保留上一次的消息
+                 空格将把消息与后续关键词分隔。
+                 若消息本身含逗号且不希望与后续文字混淆，可直接写出（只要所有逗号处均未伴随空格，插件会将它们视为同一消息）。
+                 如果逗号后还有其他词，则请用引号包裹整个消息或把逗号与空格分开以避免歧义。
     -nomsg        禁用提醒消息
     -?           查询当前配置
     -r           删除配置
@@ -944,5 +1080,8 @@ __name(apply, "apply");
   Config,
   apply,
   inject,
-  name
+  mergeReminder,
+  name,
+  parseConfigArgs,
+  tokenize
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-group-verification",
   "description": "[WIP] Koishi 群组加群验证插件，支持多关键词匹配审核、多种审核方式和详细统计功能（开发中）",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -101,6 +101,8 @@ group-verify.stats total
 
 ### 提醒消息配置
 - `-msg "消息内容"` - 设置自定义提醒消息
+  - 消息内部可包含逗号：只要所有逗号前后都没有空格，它们将被视为同一消息内容。
+  - 若逗号之后仍需写关键词，请使用引号包裹整个消息或在逗号后加空格以分隔。
 - `-nomsg` - 禁用提醒消息功能
 - 不带参数的 `-msg` 会显示帮助信息