koishi-plugin-18xx 0.0.8 → 0.0.9

package/lib/config.d.ts

@@ -1,5 +1,6 @@
 import { Server } from '@koishijs/plugin-server';
 import { Schema } from 'koishi';
+export type SendMode = 'private-only' | 'private-guild' | 'guild-only';
 export declare const name = "18xx";
 export declare const inject: {
     required: string[];
@@ -17,6 +18,7 @@ export interface Config {
             guildIds: string[];
             defaultBotIds: string[];
             botIds: string[];
+            sendMode: 'private-only' | 'private-guild' | 'guild-only';
         }[];
     };
 }

package/lib/index.js

@@ -69,7 +69,12 @@ var Config = import_koishi.Schema.object({
         defaultGuildId: import_koishi.Schema.string().default("").description("默认发送通知的群，如果不指定，通知会被发送到绑定时的群，如果绑定时没有群，通知不会发送"),
         guildIds: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("允许发送通知的群，为空表示允许在所有群发送通知"),
         defaultBotIds: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("默认发送通知的机器人，如果不指定，通知由绑定时的机器人发送"),
-        botIds: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("允许发送通知的机器人，如果先前的机器人都无法工作，将会尝试使用后面的机器人发送通知，为空表示允许所有机器人发送通知")
+        botIds: import_koishi.Schema.array(import_koishi.Schema.string()).default([]).description("允许发送通知的机器人，如果先前的机器人都无法工作，将会尝试使用后面的机器人发送通知，为空表示允许所有机器人发送通知"),
+        sendMode: import_koishi.Schema.union([
+          import_koishi.Schema.const("private-only").description("仅私聊"),
+          import_koishi.Schema.const("private-guild").description("私聊优先，失败则群聊"),
+          import_koishi.Schema.const("guild-only").description("仅群聊")
+        ]).default("private-guild").description("通知发送方式")
       })
     ).default([]).description("平台通知设置")
   }).description("通知设置")
@@ -99,7 +104,7 @@ function command(ctx, config) {
       if (!found) return "";
     }
   }, "checkSessionMiddleware");
-  ctx.command("18xx.bind <id>", "绑定账号").option("force", "-f", { authority: 4 }).usage("id 是个人资料页地址栏 profile 后面的数字").before(checkSessionMiddleware).action(async ({ session, options }, id) => {
+  ctx.command("18xx.bind <id>", "绑定账号").option("force", "-f", { authority: 4 }).usage("id 是个人资料页地址栏 profile 后面的数字").usage("需要先绑定账号，并在个人资料页 Webhook User ID 中填入你的 id").before(checkSessionMiddleware).action(async ({ session, options }, id) => {
     if (Number(id)) {
       if (!options.force) {
         const profiles = await ctx.database.get(name, { id: Number(id) });
@@ -140,7 +145,7 @@ function command(ctx, config) {
     }
     return "解绑失败";
   });
-  ctx.command("18xx.list", "列出已绑定的账号").alias("18xx.ls").action(async ({ session }) => {
+  ctx.command("18xx.list", "列出已绑定的账号").usage("需要先绑定账号，并在个人资料页 Webhook User ID 中填入你的 id").alias("18xx.ls").action(async ({ session }) => {
     const profiles = await ctx.database.get(name, { userId: session.userId });
     if (!profiles.length) {
       return "你还没有绑定账号";
@@ -148,18 +153,15 @@ function command(ctx, config) {
     return `当前已绑定${profiles.length}个账号:
 ${profiles.map((p) => `${p.id}`).join("\n")}`;
   });
-  ctx.command("18xx.on", "开启通知").usage("需要先绑定账号，并在个人资料页 webhook_user_id 中填入你的 id").action(async ({ session }) => {
+  ctx.command("18xx.on", "开启通知").usage("需要先绑定账号，并在个人资料页 Webhook User ID 中填入你的 id").action(async ({ session }) => {
     const profiles = await ctx.database.get(name, { userId: session.userId });
     if (!profiles.length) {
       return "你还没有绑定账号";
     }
-    const result = await ctx.database.upsert(
+    await ctx.database.upsert(
       name,
       profiles.map((p) => ({ ...p, notify: true }))
     );
-    if (result.matched > 1) {
-      return `开启了${result.matched || 0}个账号的通知`;
-    }
     return "通知已开启";
   });
   ctx.command("18xx.off", "关闭通知").action(async ({ session }) => {
@@ -167,20 +169,48 @@ ${profiles.map((p) => `${p.id}`).join("\n")}`;
     if (!profiles.length) {
       return "你还没有绑定账号";
     }
-    const result = await ctx.database.upsert(
+    await ctx.database.upsert(
       name,
       profiles.map((p) => ({ ...p, notify: false }))
     );
-    if (result.matched > 1) {
-      return `关闭了${result.matched || 0}个账号的通知`;
-    }
     return "通知已关闭";
   });
+  ctx.command("18xx.config <key> <value>", "修改设置").usage("需要先绑定账号，并在个人资料页 Webhook User ID 中填入你的 id").action(async ({ session }, key, value) => {
+    const profiles = await ctx.database.get(name, { userId: session.userId });
+    if (!profiles.length) {
+      return "你还没有绑定账号";
+    }
+    if (typeof key !== "string" || typeof value !== "string") {
+      return "参数错误";
+    }
+    let val = value;
+    switch (key) {
+      case "notify":
+        val = value !== "0" && Boolean(value);
+        break;
+      case "interval":
+        val = Math.max(10, Math.min(600, Number(value)));
+        break;
+    }
+    try {
+      const result = await ctx.database.upsert(
+        name,
+        profiles.map((p) => ({ ...p, [key]: val }))
+      );
+      if (result.matched) {
+        return `设置已修改：${key}=${val}`;
+      }
+    } catch (e) {
+      logger.error("Cannot update config:", e?.message || e);
+      return `未能修改设置：${key}=${val}`;
+    }
+  });
 }
 __name(command, "command");
 
 // src/server.tsx
 var import_plugin_server2 = __toESM(require("@koishijs/plugin-server"));
+var import_lru_cache = require("lru-cache");
 var import_jsx_runtime = require("@satorijs/element/jsx-runtime");
 var ForkServer = class extends import_plugin_server2.default {
   static {
@@ -206,6 +236,8 @@ var forkServer = /* @__PURE__ */ __name((ctx, config) => new Promise((resolve, r
   proxy.once("dispose", reject);
 }), "forkServer");
 var MESSAGE_REGEX = /^<@?(.*?)>\s*([\S\s]*)$/;
+var GAME_REGEX = /18xx\.games\/game\/(\d+)/;
+var sendCache = new import_lru_cache.LRUCache({ max: 1e3 });
 async function server(ctx, config) {
   const logger = ctx.logger(name);
   let server2 = ctx.server;
@@ -216,51 +248,83 @@ async function server(ctx, config) {
   if (config.notification.enable) {
     server2.post(config.notification.path, async (ptx, _next) => {
       const { text = "" } = ptx.request.body || {};
-      const result = MESSAGE_REGEX.exec(text);
-      if (!result) {
-        logger.error("Webhook格式错误", text);
+      if (!text) {
+        logger.error("Webhook 格式错误, body", ptx.request.body);
         return ptx.status = 400;
       }
-      const [, webhookId, message] = result;
-      if (!Number(webhookId) || !message) {
-        logger.error("Webhook格式错误", text);
+      const matchMessage = MESSAGE_REGEX.exec(text);
+      const webhookId = Number(matchMessage?.[1]);
+      const message = matchMessage?.[2] || "";
+      if (!webhookId || !message) {
+        logger.error("Webhook 格式错误, text", text);
         return ptx.status = 400;
       }
-      const profiles = await ctx.database.get(name, { id: Number(webhookId) });
-      logger.info("Webhook", webhookId, message, profiles);
-      const sendNotification = /* @__PURE__ */ __name(async (profile, bots = ctx.bots, guildIds = [profile.guildId]) => {
-        let success = false;
+      const matchGame = GAME_REGEX.exec(message);
+      const gameId = matchGame?.[1] || "";
+      const profiles = await ctx.database.get(name, { id: webhookId });
+      logger.debug("Webhook", webhookId, gameId, message, profiles);
+      const sendNotification = /* @__PURE__ */ __name(async (profile, sendMode = "private-guild", bots = ctx.bots, guildIds = [profile.guildId]) => {
+        const sendCacheKey = [webhookId, profile.userId, gameId].join("|");
         for (const bot of bots) {
           for (const guildId of guildIds) {
             try {
-              const result2 = await bot.sendMessage(
+              let result;
+              const sendPrivate = /* @__PURE__ */ __name(() => bot.sendPrivateMessage(profile.userId, message, guildId), "sendPrivate");
+              const sendGuild = /* @__PURE__ */ __name(() => bot.sendMessage(
                 guildId,
                 /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
-                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("at", { id: profile.userId, name: webhookId }),
+                  /* @__PURE__ */ (0, import_jsx_runtime.jsx)("at", { id: profile.userId, name: `${webhookId}` }),
                   " ",
                   message
                 ] })
-              );
-              logger.info("通知发送成功", result2, message, profile);
-              success = true;
-              break;
+              ), "sendGuild");
+              switch (sendMode) {
+                case "private-only":
+                  result = await sendPrivate();
+                  break;
+                case "private-guild":
+                  try {
+                    result = await sendPrivate();
+                  } catch (e) {
+                    logger.error("私聊消息发送失败，尝试群消息", e, sendCacheKey, message);
+                    result = await sendGuild();
+                  }
+                  break;
+                case "guild-only":
+                  result = await sendGuild();
+                  break;
+              }
+              if (result?.length > 0) {
+                logger.info("通知发送成功", result, sendCacheKey, message);
+                sendCache.set(sendCacheKey, { ts: Date.now() });
+                return true;
+              }
             } catch (e) {
-              logger.error("通知发送失败", e, message, profile);
+              logger.error("通知发送失败", e, sendCacheKey, message);
             }
           }
-          if (success) {
-            break;
-          }
-        }
-        if (!success) {
-          logger.info("未能发送通知", message, profile);
         }
-        return success;
+        logger.info("未能发送通知", sendCacheKey, message);
+        return false;
       }, "sendNotification");
-      for (const profile of profiles.filter((profile2) => profile2.notify)) {
+      const tryProfile = /* @__PURE__ */ __name(async (profile) => {
+        const sendCacheKey = [webhookId, profile.userId, gameId].join("|");
+        if (sendCache.has(sendCacheKey)) {
+          const { ts: lastTimestamp, cancel: cancelPrevTask } = sendCache.get(sendCacheKey);
+          cancelPrevTask?.();
+          const nextTimestamp = lastTimestamp + profile.interval * 1e3;
+          const now = Date.now();
+          if (nextTimestamp > now) {
+            logger.debug("通知发送间隔小于限制", sendCacheKey, nextTimestamp - now);
+            const cancel = ctx.setTimeout(() => tryProfile(profile), nextTimestamp - now);
+            sendCache.set(sendCacheKey, { ts: lastTimestamp, cancel });
+            return;
+          }
+          sendCache.delete(sendCacheKey);
+        }
         if (!config.notification.items.length) {
           await sendNotification(profile);
-          continue;
+          return;
         }
         for (const item of config.notification.items.filter((item2) => !item2.platform || item2.platform === profile.platform)) {
           if (item.botIds.length && !item.botIds.includes(profile.botId) && !item.defaultBotIds.includes(profile.botId)) {
@@ -279,10 +343,13 @@ async function server(ctx, config) {
             )
           );
           const guildIds = Array.from(new Set([item.defaultGuildId, profile.guildId, ...item.guildIds].filter(Boolean)));
-          if (await sendNotification(profile, bots, guildIds)) {
-            break;
+          if (await sendNotification(profile, item.sendMode, bots, guildIds)) {
+            return;
           }
         }
+      }, "tryProfile");
+      for (const profile of profiles.filter((profile2) => profile2.notify)) {
+        tryProfile(profile);
       }
       return ptx.status = 200;
     });
@@ -302,6 +369,10 @@ function apply(ctx, config) {
     notify: {
       type: "boolean",
       initial: true
+    },
+    interval: {
+      type: "integer",
+      initial: 30
     }
   });
   command(ctx, config);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-18xx",
   "description": "18xxGames 机器人",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -29,7 +29,8 @@
   "peerDependencies": {
     "@koishijs/plugin-server": "^3.2.7",
     "@satorijs/element": "^3.1.8",
-    "koishi": "^4.18.7"
+    "koishi": "^4.18.7",
+    "lru-cache": "^11.1.0"
   },
   "koishi": {
     "description": {