koishi-plugin-18xx 0.0.1

package/lib/command.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import { Config } from './config';
+export declare function command(ctx: Context, config: Config): void;

package/lib/config.d.ts

@@ -0,0 +1,20 @@
+import { Schema } from 'koishi';
+export declare const name = "18xx";
+export declare const inject: {
+    required: string[];
+};
+export interface Config {
+    notification: {
+        enable: boolean;
+        path: string;
+        items: {
+            platform: string;
+            defaultGuildId: string;
+            guildIds: string[];
+            defaultBotIds: string[];
+            botIds: string[];
+        }[];
+    };
+}
+export declare const Config: Schema<Config>;
+export default Config;

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+import { Context } from 'koishi';
+import { Config, name, inject } from './config';
+export { name, inject };
+export { Config };
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,252 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config.ts
+var import_koishi = require("koishi");
+var name = "18xx";
+var inject = {
+  required: ["server", "database"]
+  // optional: ['puppeteer'],
+};
+var Config = import_koishi.Schema.object({
+  notification: import_koishi.Schema.object({
+    enable: import_koishi.Schema.boolean().default(true).description("启用通知"),
+    path: import_koishi.Schema.string().default("/18xx").description("Webhook 监听路径"),
+    items: import_koishi.Schema.array(
+      import_koishi.Schema.object({
+        platform: import_koishi.Schema.string().default("").description("平台，为空表示不限制"),
+        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("允许发送通知的机器人，如果先前的机器人都无法工作，将会尝试使用后面的机器人发送通知，为空表示允许所有机器人发送通知")
+      })
+    ).default([]).description("平台通知设置")
+  }).description("通知设置")
+});
+
+// src/command.ts
+function command(ctx, config) {
+  const logger = ctx.logger(name);
+  const checkSessionMiddleware = /* @__PURE__ */ __name(({ session }) => {
+    if (!session.guildId) {
+      return "请在群里使用这个命令";
+    }
+    if (config.notification.items.length) {
+      let found = false;
+      for (const { botIds, guildIds, defaultBotIds, defaultGuildId } of config.notification.items.filter(
+        (item) => !item.platform || item.platform === session.platform
+      )) {
+        if (botIds.length && !botIds.includes(session.selfId) && !defaultBotIds.includes(session.selfId)) {
+          continue;
+        }
+        if (guildIds.length && !guildIds.includes(session.guildId) && defaultGuildId !== session.guildId) {
+          continue;
+        }
+        found = true;
+        break;
+      }
+      if (!found) return "";
+    }
+  }, "checkSessionMiddleware");
+  ctx.command("18xx.bind <id>", "绑定 18xx.games 账号").usage("id 是个人资料页地址栏 profile 后面的数字").before(checkSessionMiddleware).action(async ({ session }, id) => {
+    if (Number(id)) {
+      const result = await ctx.database.upsert(name, [
+        {
+          id: Number(id),
+          userId: session.userId,
+          platform: session.platform,
+          botId: session.selfId,
+          guildId: session.guildId
+        }
+      ]);
+      if (result.inserted) {
+        return `${id} 绑定成功`;
+      } else {
+        return `${id} 重新绑定成功`;
+      }
+    } else {
+      return "绑定失败";
+    }
+  });
+  ctx.command("18xx.unbind <id>", "取消绑定 18xx.games 账号").usage("id 是个人资料页地址栏 profile 后面的数字").action(async ({ session }, id) => {
+    const result = await ctx.database.remove(name, { id: Number(id), userId: session.userId });
+    if (!result.matched) {
+      return "你还没有绑定 18xx.games 账号";
+    }
+    if (result.removed) {
+      return `${id} 解绑成功`;
+    }
+    return "解绑失败";
+  });
+  ctx.command("18xx.list", "列出已绑定的 18xx.games 账号").alias("18xx.ls").action(async ({ session }) => {
+    const profiles = await ctx.database.get(name, { userId: session.userId });
+    if (!profiles.length) {
+      return "你还没有绑定 18xx.games 账号";
+    }
+    return `当前已绑定${profiles.length}个账号:
+${profiles.map((p) => `${p.id}`).join("\n")}`;
+  });
+  ctx.command("18xx.on", "开启 18xx.games 通知").usage("需要先绑定 18xx.games 账号，并在个人资料页 webhook_user_id 中填入你的 id").action(async ({ session }) => {
+    const profiles = await ctx.database.get(name, { userId: session.userId });
+    if (!profiles.length) {
+      return "你还没有绑定 18xx.games 账号";
+    }
+    const result = await ctx.database.upsert(
+      name,
+      profiles.map((p) => ({ ...p, notify: true }))
+    );
+    if (result.matched > 1) {
+      return `开启了${result.matched || 0}个账号的通知`;
+    }
+    return "通知已开启";
+  });
+  ctx.command("18xx.off", "关闭 18xx.games 通知").action(async ({ session }) => {
+    const profiles = await ctx.database.get(name, { userId: session.userId });
+    if (!profiles.length) {
+      return "你还没有绑定 18xx.games 账号";
+    }
+    const result = await ctx.database.upsert(
+      name,
+      profiles.map((p) => ({ ...p, notify: false }))
+    );
+    if (result.matched > 1) {
+      return `关闭了${result.matched || 0}个账号的通知`;
+    }
+    return "通知已关闭";
+  });
+}
+__name(command, "command");
+
+// src/server.tsx
+var import_jsx_runtime = require("@satorijs/element/jsx-runtime");
+var MESSAGE_REGEX = /^<@?(.*?)>\s*(.*)$/;
+function server(ctx, config) {
+  const logger = ctx.logger(name);
+  if (config.notification.enable) {
+    ctx.server.post(config.notification.path, async (ptx, _next) => {
+      const { text = "" } = ptx.request.body || {};
+      const result = MESSAGE_REGEX.exec(text);
+      if (!result) {
+        logger.error("Webhook格式错误");
+        return ptx.status = 400;
+      }
+      const [, webhookId, message] = result;
+      if (!Number(webhookId) || !message) {
+        logger.error("Webhook格式错误");
+        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;
+        for (const bot of bots) {
+          for (const guildId of guildIds) {
+            try {
+              const result2 = await 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 }),
+                  " ",
+                  message
+                ] })
+              );
+              logger.info("通知发送成功", result2, message, profile);
+              success = true;
+              break;
+            } catch (e) {
+              logger.error("通知发送失败", e, message, profile);
+            }
+          }
+          if (success) {
+            break;
+          }
+        }
+        if (!success) {
+          logger.info("未能发送通知", message, profile);
+        }
+        return success;
+      }, "sendNotification");
+      for (const profile of profiles.filter((profile2) => profile2.notify)) {
+        if (!config.notification.items.length) {
+          await sendNotification(profile);
+          continue;
+        }
+        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)) {
+            continue;
+          }
+          if (item.guildIds.length && !item.guildIds.includes(profile.guildId) && item.defaultGuildId !== profile.guildId) {
+            continue;
+          }
+          const bots = Array.from(
+            new Set(
+              [
+                ...item.defaultBotIds.map((id) => ctx.bots.find((bot) => bot.selfId === id)),
+                ctx.bots.find((bot) => bot.selfId === profile.botId),
+                ...item.botIds.map((id) => ctx.bots.find((bot) => bot.selfId === id))
+              ].filter(Boolean)
+            )
+          );
+          const guildIds = Array.from(new Set([item.defaultGuildId, profile.guildId, ...item.guildIds].filter(Boolean)));
+          if (await sendNotification(profile, bots, guildIds)) {
+            break;
+          }
+        }
+      }
+      return ptx.status = 200;
+    });
+    logger.info("启用通知服务");
+  }
+}
+__name(server, "server");
+
+// src/index.ts
+function apply(ctx, config) {
+  ctx.model.extend(name, {
+    id: "integer",
+    userId: "string",
+    platform: "string",
+    botId: "string",
+    guildId: "string",
+    notify: {
+      type: "boolean",
+      initial: true
+    }
+  });
+  command(ctx, config);
+  server(ctx, config);
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/lib/server.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'koishi';
+import { Config } from './config';
+export declare function server(ctx: Context, config: Config): void;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "koishi-plugin-18xx",
+  "description": "18xxGames 机器人",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "contributors": [
+    "SeaLoong <sealoongw@foxmail.com>"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/SeaLoong/koishi-plugin-18xx",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SeaLoong/koishi-plugin-18xx.git"
+  },
+  "keywords": [
+    "koishi",
+    "18xxgames",
+    "webhook"
+  ],
+  "devDependencies": {
+    "@koishijs/plugin-adapter-onebot": "^6.0.2",
+    "@koishijs/plugin-server": "^3.2.7",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "koishi": "^4.18.7",
+    "@satorijs/element": "^3.1.8"
+  },
+  "koishi": {
+    "description": {
+      "en": "18xxGames Bot",
+      "zh": "18xxGames 机器人"
+    },
+    "service": {
+      "required": [
+        "server",
+        "database"
+      ]
+    },
+    "locales": [
+      "en",
+      "zh"
+    ]
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-18xx
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-18xx?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-18xx)
+
+18xxGames 机器人