koishi-plugin-mediawiki-fix 0.0.1

package/lib/index.d.ts

@@ -0,0 +1,159 @@
+/**
+ * koishi-plugin-mediawiki
+ * @desc MediaWiki plugin for Koishijs
+ * @author Koishijs(机智的小鱼君) <dragon-fish@qq.com>
+ * @license Apache-2.0
+ */
+import { Context, h, Logger, Schema } from 'koishi';
+export interface InfoboxDefinition {
+    match: ((url: URL) => boolean) | string;
+    selector: string | string[];
+    injectStyles?: string;
+    skin?: string;
+}
+export interface Config {
+    defaultApiUrl?: string;
+    cmdAuthWiki: number;
+    cmdAuthConnect: number;
+    cmdAuthSearch: number;
+    searchIfNotExist: boolean;
+    showDetailsByDefault: boolean;
+    customInfoboxes: InfoboxDefinition[];
+}
+export type MWPages = MWPage[];
+export interface MWPage {
+    pageid: number;
+    ns: number;
+    title: string;
+    extract: string;
+    contentmodel: string;
+    pagelanguage: string;
+    pagelanguagehtmlcode: string;
+    pagelanguagedir: string;
+    touched: string;
+    lastrevid: number;
+    length: number;
+    fullurl: string;
+    editurl: string;
+    canonicalurl: string;
+    displaytitle: string;
+    special?: boolean;
+    invalid?: boolean;
+    invalidreason?: string;
+    missing?: boolean;
+}
+export type MWRedirects = MWRedirect[];
+export interface MWRedirect {
+    from: string;
+    to: string;
+    tofragment?: string;
+}
+export type MWInterwikiLinks = MWInterwiki[];
+export interface MWInterwiki {
+    title: string;
+    iw: string;
+    url: string;
+}
+export type MWSpecialPageAliases = MWSpecialPageAlias[];
+export interface MWSpecialPageAlias {
+    realname: string;
+    aliases: string[];
+}
+export type MWNamespaceAliases = MWNamespaceAlias[];
+export interface MWNamespaceAlias {
+    id: number;
+    alias: string;
+}
+export type MWNamespaces = Record<string, MWNamespace>;
+export interface MWNamespace {
+    id: number;
+    case: string;
+    name: string;
+    subpages: boolean;
+    canonical: string;
+    content: boolean;
+    nonincludable: boolean;
+}
+export interface MWApiResponseQueryPagesWithSiteinfo {
+    query: {
+        pages: MWPages;
+        redirects?: MWRedirects;
+        interwiki?: MWInterwikiLinks;
+        specialpagealiases: MWSpecialPageAliases;
+        namespacealiases: MWNamespaceAliases;
+        namespaces: MWNamespaces;
+    };
+}
+export interface MWApiResponsQueryPagesGeneratedBySearch {
+    query: {
+        searchinfo: {
+            totalhits: number;
+        };
+        pages: {
+            pageid: number;
+            ns: number;
+            title: string;
+            index: number;
+            extract: string;
+        }[];
+        search: {
+            ns: number;
+            title: string;
+            pageid: number;
+        }[];
+    };
+}
+declare module 'koishi' {
+    interface Channel {
+        mwApi?: string;
+    }
+}
+export declare const name = "mediawiki";
+export default class PluginMediawiki {
+    #private;
+    ctx: Context;
+    config: Partial<Config>;
+    static inject: string[];
+    INFOBOX_DEFINITION: InfoboxDefinition[];
+    static Config: Schema<Schemastery.ObjectS<{
+        defaultApiUrl: Schema<string, string>;
+        cmdAuthWiki: Schema<number, number>;
+        cmdAuthConnect: Schema<number, number>;
+        cmdAuthSearch: Schema<number, number>;
+        searchIfNotExist: Schema<boolean, boolean>;
+        showDetailsByDefault: Schema<boolean, boolean>;
+        customInfoboxes: Schema<Schemastery.ObjectS<{
+            match: Schema<string, string>;
+            selector: Schema<string[], string[]>;
+            injectStyles: Schema<string, string>;
+            skin: Schema<string, string>;
+        }>[], Schemastery.ObjectT<{
+            match: Schema<string, string>;
+            selector: Schema<string[], string[]>;
+            injectStyles: Schema<string, string>;
+            skin: Schema<string, string>;
+        }>[]>;
+    }>, Schemastery.ObjectT<{
+        defaultApiUrl: Schema<string, string>;
+        cmdAuthWiki: Schema<number, number>;
+        cmdAuthConnect: Schema<number, number>;
+        cmdAuthSearch: Schema<number, number>;
+        searchIfNotExist: Schema<boolean, boolean>;
+        showDetailsByDefault: Schema<boolean, boolean>;
+        customInfoboxes: Schema<Schemastery.ObjectS<{
+            match: Schema<string, string>;
+            selector: Schema<string[], string[]>;
+            injectStyles: Schema<string, string>;
+            skin: Schema<string, string>;
+        }>[], Schemastery.ObjectT<{
+            match: Schema<string, string>;
+            selector: Schema<string[], string[]>;
+            injectStyles: Schema<string, string>;
+            skin: Schema<string, string>;
+        }>[]>;
+    }>>;
+    constructor(ctx: Context, config?: Partial<Config>);
+    get logger(): Logger;
+    shotInfobox(url: string, silence?: boolean): Promise<string | h>;
+    createInjectStylesFromDefinition({ selector, injectStyles, }: InfoboxDefinition): string;
+}

package/lib/index.js

@@ -0,0 +1,588 @@
+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, {
+  default: () => PluginMediawiki,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+var import_wiki_saikou = require("wiki-saikou");
+var INFOBOX_DEFINITION = [
+  // 萌娘百科
+  {
+    match: /* @__PURE__ */ __name((url) => url.host.endsWith("moegirl.org.cn"), "match"),
+    selector: [
+      ".mw-parser-output .infotemplatebox",
+      ".mw-parser-output table.infobox2",
+      ".mw-parser-output table.infoboxSpecial",
+      ".mw-parser-output table.infobox"
+    ],
+    injectStyles: `
+      .mw-parser-output .infotemplatebox {
+        margin: 1rem !important;
+      }
+    `,
+    skin: "apioutput"
+  },
+  // Minecraft Wiki
+  {
+    match: /* @__PURE__ */ __name((url) => url.host === "minecraft.fandom.com", "match"),
+    selector: [".mw-parser-output .notaninfobox"],
+    skin: "apioutput"
+  },
+  // Fandom (basic)
+  {
+    match: /* @__PURE__ */ __name((url) => url.host.endsWith("fandom.com"), "match"),
+    selector: [".mw-parser-output aside.portable-infobox"],
+    skin: "apioutput"
+  },
+  // 万界规划局
+  {
+    match: /* @__PURE__ */ __name((url) => url.host.endsWith("wjghj.cn"), "match"),
+    selector: [".mw-parser-output .portable-infobox:not(.pi-theme-顶部提示小)"],
+    skin: "apioutput"
+  },
+  // 最终幻想XIV中文维基
+  {
+    match: /* @__PURE__ */ __name((url) => url.host === "ff14.huijiwiki.com", "match"),
+    selector: [
+      ".mw-parser-output .infobox-item",
+      ".mw-parser-output .quest-frame",
+      ".mw-parser-output .instance-infobox",
+      ".mw-parser-output .ff14-infobox"
+    ]
+  }
+];
+var DEFAULT_CONFIGS = {
+  cmdAuthWiki: 1,
+  cmdAuthConnect: 2,
+  cmdAuthSearch: 1,
+  searchIfNotExist: false,
+  showDetailsByDefault: false,
+  customInfoboxes: []
+};
+var MOCK_HEADERS = [
+  {
+    match: /* @__PURE__ */ __name((url) => url.hostname.includes("huijiwiki.com"), "match"),
+    headers: {
+      "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.67"
+    }
+  }
+];
+function resolveBrackets(str) {
+  return str.replace(new RegExp("[", "g"), "[").replace(new RegExp("]", "g"), "]");
+}
+__name(resolveBrackets, "resolveBrackets");
+function useApi(baseURL) {
+  const api = new import_wiki_saikou.MediaWikiApi(baseURL);
+  const matchedMockHeader = MOCK_HEADERS.find(
+    (item) => item.match(new URL(baseURL))
+  );
+  if (matchedMockHeader) {
+    api.request.interceptors.request.use((ctx) => {
+      ctx.headers = { ...ctx.headers, ...matchedMockHeader.headers };
+      return ctx;
+    });
+  }
+  return api;
+}
+__name(useApi, "useApi");
+function getWikiTitleDBKey(raw) {
+  const title = raw.replace(/[\s_]+/g, " ").trim().replace(/\s+/g, "_");
+  return title[0].toUpperCase() + title.slice(1);
+}
+__name(getWikiTitleDBKey, "getWikiTitleDBKey");
+function getWikiDisplayTitle(raw) {
+  const title = raw.replace(/[\s_]+/g, " ").trim();
+  return title[0].toUpperCase() + title.slice(1);
+}
+__name(getWikiDisplayTitle, "getWikiDisplayTitle");
+function parseTitlesFromText(str) {
+  str = resolveBrackets(str);
+  const reg = /\[\[(.+?)\]\]/g;
+  return Array.from(
+    new Set(
+      Array.from(str.matchAll(reg)).map((i) => i[1].split("|")[0]).map(getWikiTitleDBKey)
+    )
+  ).filter((i) => !!i);
+}
+__name(parseTitlesFromText, "parseTitlesFromText");
+function getUrl(base, params = {}, script = "index") {
+  const query = Object.keys(params).length ? "?" + new URLSearchParams(params) : "";
+  return `${base.replace(
+    "/api.php",
+    `/${script ? script.trim() : "index"}.php`
+  )}${query}`;
+}
+__name(getUrl, "getUrl");
+function isValidApi(api) {
+  let url;
+  try {
+    url = new URL(api);
+  } catch (err) {
+    return false;
+  }
+  const { protocol, pathname } = url;
+  if (protocol.startsWith("http") && pathname.endsWith("/api.php")) {
+    return true;
+  }
+  return false;
+}
+__name(isValidApi, "isValidApi");
+var BulkMessageBuilder = class {
+  constructor(session) {
+    this.session = session;
+    this.#content = session.content || "";
+    this.#bot = {
+      userId: this.session.bot.userId,
+      nickname: this.session.bot.user?.name || "BOT"
+    };
+    this.#author = {
+      userId: session.userId,
+      nickname: session.username
+    };
+  }
+  static {
+    __name(this, "BulkMessageBuilder");
+  }
+  #figure = (0, import_koishi.h)("message", { forward: true });
+  #bot;
+  #author;
+  #content;
+  #isPrependOriginal = false;
+  all() {
+    return this.#figure;
+  }
+  get figure() {
+    return this.#figure;
+  }
+  addLine(author, message) {
+    this.#figure.children.push((0, import_koishi.h)("message", author, message));
+    return this;
+  }
+  botSay(msg) {
+    this.addLine(this.#bot, msg);
+    return this;
+  }
+  authorSay(msg) {
+    this.addLine(this.#author, msg);
+    return this;
+  }
+  prependOriginal() {
+    if (this.#isPrependOriginal) return this;
+    this.#isPrependOriginal = true;
+    this.#figure.children.unshift((0, import_koishi.h)("message", this.#author, this.#content));
+    return this;
+  }
+};
+var name = "mediawiki";
+var PluginMediawiki = class {
+  constructor(ctx, config = DEFAULT_CONFIGS) {
+    this.ctx = ctx;
+    this.config = config;
+    this.config = { ...DEFAULT_CONFIGS, ...config };
+    this.INFOBOX_DEFINITION = [
+      ...this.config.customInfoboxes || [],
+      ...INFOBOX_DEFINITION
+    ];
+    ctx.model.extend("channel", {
+      mwApi: "string"
+    });
+    this.#initCommands();
+  }
+  static {
+    __name(this, "PluginMediawiki");
+  }
+  static inject = ["database", "puppeteer"];
+  INFOBOX_DEFINITION;
+  static Config = import_koishi.Schema.object({
+    defaultApiUrl: import_koishi.Schema.string().description("全局默认的 MediaWiki API 地址。当群聊未绑定特定 Wiki 时，将使用此地址。"),
+    cmdAuthWiki: import_koishi.Schema.number().description("指令`wiki`的权限等级：基础指令，请求条目链接与基本信息等").default(1),
+    cmdAuthConnect: import_koishi.Schema.number().description("指令`wiki.connect`的权限等级：将wiki绑定到群聊").default(2),
+    cmdAuthSearch: import_koishi.Schema.number().description("指令`wiki.search`的权限等级：在绑定的wiki中搜索").default(1),
+    searchIfNotExist: import_koishi.Schema.boolean().description(
+      "触发`wiki`指令时，结果有且仅有一个不存在的主名字空间的页面时否自动触发搜索"
+    ),
+    showDetailsByDefault: import_koishi.Schema.boolean().description(
+      "触发`wiki`指令时，是否默认附带页面摘要和信息框截图"
+    ),
+    customInfoboxes: import_koishi.Schema.array(
+      import_koishi.Schema.object({
+        match: import_koishi.Schema.string().description(
+          "正则表达式，决定该组信息框定义是否匹配当前请求的URL。(URL示例 `https://example.com/wiki/PageName`，填写示例：`^https?://example\\\\\\\\.com/`)"
+        ).required(),
+        selector: import_koishi.Schema.array(String).description("信息框的选择器").required(),
+        injectStyles: import_koishi.Schema.string().description("额外插入的CSS").role("textarea"),
+        skin: import_koishi.Schema.string().description(
+          "渲染时使用的皮肤，建议配置为 `apioutput` 提高加载速度"
+        )
+      })
+    ).description("自定义信息框定义组，每一个定义组至少需要match以及selector")
+  });
+  get logger() {
+    return this.ctx.logger("mediawiki");
+  }
+  #initCommands() {
+    this.ctx.command("wiki [titles:text]", "MediaWiki 相关功能", {
+      authority: this.config.cmdAuthWiki
+    }).example("wiki 页面 - 获取页面链接").channelFields(["mwApi"]).option("details", "-d 显示页面的更多资讯", {
+      type: "boolean",
+      fallback: this.config.showDetailsByDefault
+    }).option("search", "-s 如果页面不存在就进行搜索", {
+      type: "boolean",
+      fallback: this.config.searchIfNotExist
+    }).option("quiet", "-q 静默执行（忽略未绑定提示）", {
+      type: "boolean",
+      // @ts-ignore
+      hidden: true
+    }).action(async ({ session, options }, titlesInput = "") => {
+      if (!session?.channel) {
+        return "该指令需要在群聊（频道）中使用。";
+      }
+      let mwApi = session.channel.mwApi;
+      if (!mwApi) {
+        if (this.config.defaultApiUrl) {
+          mwApi = this.config.defaultApiUrl;
+        } else {
+          return options?.quiet ? "" : session.execute("wiki.connect -h");
+        }
+      }
+      if (!titlesInput) {
+        return getUrl(mwApi);
+      }
+      const api = useApi(mwApi);
+      const titles = Array.from(
+        new Set(titlesInput.split("|").map(getWikiDisplayTitle))
+      ).map((i) => {
+        return {
+          name: i.split("#")[0],
+          anchor: i.split("#")[1] ? "#" + encodeURI(i.split("#")[1]) : ""
+        };
+      }).filter((i) => !!i.name).slice(0, 5);
+      const { data } = await api.get({
+        action: "query",
+        prop: "extracts|info",
+        meta: "siteinfo",
+        siprop: "specialpagealiases|namespacealiases|namespaces",
+        iwurl: 1,
+        titles: titles.map((i) => i.name),
+        redirects: 1,
+        converttitles: 1,
+        exchars: "120",
+        exlimit: "max",
+        explaintext: 1,
+        exintro: 1,
+        exsectionformat: "plain",
+        inprop: "url|displaytitle"
+      }).catch((e) => {
+        session.send(`查询时遇到问题：${e || "-"}`);
+        throw e;
+      });
+      this.logger.debug("QUERY DATA", data.query);
+      const { pages, redirects, interwiki, specialpagealiases, namespaces } = data.query;
+      const dangerPageNames = ["Mypage", "Mytalk"];
+      const dangerPages = specialpagealiases.filter((i) => dangerPageNames.includes(i.realname)).map((i) => i.aliases).flat(Infinity);
+      const specialNsName = namespaces["-1"].name;
+      const pageMsgs = pages?.map((page) => {
+        const msg = [];
+        let pageRedirect = redirects?.find(({ to }) => to === page.title);
+        let pageAnchor = titles.find(
+          (i) => i.name.toLocaleLowerCase() === page.title.toLocaleLowerCase()
+        )?.anchor || "";
+        if (pageRedirect && pageRedirect.from.split(":")[0] === specialNsName && dangerPages.includes(
+          pageRedirect.from.split(":")?.[1].split("/")[0] || ""
+        )) {
+          page = {
+            ...page,
+            ns: -1,
+            title: pageRedirect.from,
+            special: true
+          };
+          pageRedirect = void 0;
+          delete page.missing;
+        }
+        const {
+          pageid,
+          title: pagetitle,
+          missing,
+          invalid,
+          canonicalurl,
+          special,
+          editurl
+        } = page;
+        msg.push(`您要的“${pagetitle}”：`);
+        if (pageRedirect) {
+          const { from, to, tofragment } = pageRedirect || {};
+          msg.push(
+            `重定向：[${from}] → [${to}${tofragment ? "#" + tofragment : ""}]`
+          );
+          if (tofragment) pageAnchor = "#" + encodeURI(tofragment);
+        }
+        if (invalid !== void 0) {
+          msg.push(
+            `😟页面名称不合法：${JSON.stringify(page.invalidreason) || "原因未知"}`
+          );
+        } else if (special) {
+          msg.push(
+            `${getUrl(mwApi, {
+              title: pagetitle
+            })}${pageAnchor} (${missing ? "不存在的" : ""}特殊页面)`
+          );
+        } else if (missing !== void 0) {
+          if (!options?.search) {
+            msg.push(`${editurl} (💔页面不存在)`);
+          } else {
+            msg.push(`${editurl}
+💡页面不存在，即将搜索wiki……`);
+          }
+        } else {
+          const shortUrl = getUrl(mwApi, { curid: String(pageid) });
+          msg.push(
+            (shortUrl.length <= canonicalurl.length ? shortUrl : canonicalurl) + pageAnchor
+          );
+        }
+        if (options?.details && page.extract) {
+          msg.push(page.extract);
+        }
+        return msg.join("\n");
+      }) || [];
+      const interwikiMsgs = interwiki?.map((item) => {
+        return [`跨语言链接：`, item.url].join("\n");
+      }) || [];
+      const allMsgList = [...pageMsgs, ...interwikiMsgs];
+      let finalMsg = "";
+      if (allMsgList.length === 1) {
+        finalMsg = import_koishi.h.quote(session.messageId) + allMsgList[0];
+      } else if (allMsgList.length > 1) {
+        const msgBuilder = new BulkMessageBuilder(session);
+        allMsgList.forEach((i) => {
+          msgBuilder.botSay(i);
+        });
+        finalMsg = msgBuilder.prependOriginal().all();
+      }
+      if (pages && pages.length === 1 && pages[0].ns === 0 && !pages[0].missing && !pages[0].invalid && options?.details) {
+        await session.send(finalMsg);
+        const infoboxImage = await this.shotInfobox(pages[0].canonicalurl, true);
+        if (infoboxImage) {
+          await session.send(infoboxImage);
+        }
+      } else if (options?.search && pages.length === 1 && pages[0].ns === 0 && pages[0].missing && !pages[0].invalid) {
+        await session.send(finalMsg);
+        await session.execute(`wiki.search ${pages[0].title}`);
+      } else {
+        return finalMsg;
+      }
+    });
+    this.ctx.middleware(async (session, next) => {
+      await next();
+      if (!session.channel) return;
+      const titles = parseTitlesFromText(session.content || "");
+      if (!titles.length) {
+        return;
+      }
+      session.execute(`wiki -q ${titles.join("|")}`);
+    });
+    this.ctx.command("wiki.connect [api:string]", "将群聊与 MediaWiki 网站连接", {
+      authority: this.config.cmdAuthConnect
+    }).alias("wiki.link").channelFields(["mwApi"]).action(async ({ session }, api) => {
+      if (!session?.channel) {
+        return "该指令需要在群聊（频道）中用于绑定 Wiki。";
+      }
+      const { channel } = session;
+      if (!api) {
+        return channel.mwApi ? `本群已与 ${channel.mwApi} 连接~` : "本群未连接到 MediaWiki 网站，请使用“wiki.connect <api网址>”进行连接。";
+      } else if (isValidApi(api)) {
+        channel.mwApi = api;
+        await session.channel.$update();
+        return session.execute("wiki.connect");
+      } else {
+        return "输入的不是合法 api.php 网址。";
+      }
+    });
+    this.ctx.command("wiki.search [srsearch:text]", "在绑定的 Wiki 中搜索", {
+      authority: this.config.cmdAuthSearch
+    }).channelFields(["mwApi"]).action(async ({ session }, keywords) => {
+      if (!session?.channel) {
+        return "该指令需要在已绑定 Wiki 的群聊（频道）中使用。";
+      }
+      let mwApi = session.channel.mwApi;
+      if (!mwApi) {
+        if (this.config.defaultApiUrl) {
+          mwApi = this.config.defaultApiUrl;
+        } else {
+          return session.execute("wiki.connect -h");
+        }
+      }
+      if (!keywords) {
+        session.sendQueued("要搜索什么呢？(输入空行或句号取消)");
+        keywords = (await session.prompt(30 * 1e3)).trim();
+        if (!keywords || keywords === "." || keywords === "。") return "";
+      }
+      const api = useApi(mwApi);
+      const {
+        data: {
+          query: { searchinfo, search, pages }
+        }
+      } = await api.post({
+        action: "query",
+        prop: "extracts",
+        list: "search",
+        generator: "search",
+        exchars: "120",
+        exintro: 1,
+        explaintext: 1,
+        exsectionformat: "plain",
+        srsearch: keywords,
+        srnamespace: "0",
+        srlimit: "5",
+        srinfo: "totalhits",
+        srprop: "",
+        gsrsearch: keywords,
+        gsrnamespace: "0",
+        gsrlimit: "5"
+      });
+      const bulk = new BulkMessageBuilder(session);
+      if (search.length < 1) {
+        return `💔找不到与“${keywords}”匹配的结果。`;
+      } else if (search.length === 1) {
+        return session.execute(`wiki -d ${search[0].title}`);
+      } else {
+        bulk.prependOriginal();
+        bulk.botSay(
+          `🔍关键词“${keywords}”共匹配到 ${searchinfo?.totalhits || "∅"} 个相关结果，我来简单整理一下前 ${search.length} 个结果：`
+        );
+      }
+      pages.sort((a, b) => a.index - b.index).forEach((item, index) => {
+        bulk.botSay(
+          `(${index + 1}) ${item.title}
+${item.extract}
+${getUrl(session.channel.mwApi, { curid: String(item.pageid) })}`
+        );
+      });
+      return bulk.all();
+    });
+  }
+  async shotInfobox(url, silence = false) {
+    if (!this.ctx.puppeteer) {
+      return silence ? "" : "无法获取截图，请安装 puppeteer 插件后再试~";
+    }
+    const matched = this.INFOBOX_DEFINITION.find((i) => {
+      if (typeof i.match === "string") {
+        return new RegExp(i.match).test(url);
+      } else {
+        return i.match(new URL(url));
+      }
+    });
+    if (!matched) return "";
+    this.logger.info("SHOT_INFOBOX", url, matched.selector);
+    const start = Date.now();
+    const timeSpend = /* @__PURE__ */ __name(() => ((Date.now() - start) / 1e3).toFixed(3) + "s", "timeSpend");
+    const pageURL = new URL(url);
+    if (matched.skin) {
+      pageURL.searchParams.set("useskin", matched.skin);
+    }
+    let pageLoaded = false;
+    const page = await this.ctx.puppeteer.page();
+    await page.setViewport({ width: 960, height: 720 });
+    try {
+      await page.goto(pageURL.href, {
+        timeout: 15 * 1e3,
+        waitUntil: "networkidle0"
+      });
+      pageLoaded = true;
+    } catch (e) {
+      this.logger.warn("SHOT_INFOBOX", `Navigation timeout or failed: ${e}`);
+      const contentExists = await page.$(".mw-parser-output");
+      if (contentExists) {
+        this.logger.info("SHOT_INFOBOX", "Content exists, proceeding with screenshot.");
+        pageLoaded = true;
+      } else {
+        this.logger.warn("SHOT_INFOBOX", "Content not found after timeout.");
+      }
+    }
+    if (!pageLoaded) {
+      await page.close();
+      return "";
+    }
+    try {
+      await page.addStyleTag({
+        content: this.createInjectStylesFromDefinition(matched)
+      });
+    } catch (e) {
+      this.logger.warn("SHOT_INFOBOX", "Inject styles error", e);
+    }
+    try {
+      const selector = Array.isArray(matched.selector) ? matched.selector.join(", ") : matched.selector;
+      const target = await page.waitForSelector(selector, { timeout: 5e3 }).catch(() => null);
+      if (!target) {
+        this.logger.info("SHOT_INFOBOX", "Canceled", "Missing target or timed out waiting for selector:", selector);
+        await page.close();
+        return "";
+      }
+      const img = await target.screenshot({ type: "jpeg", quality: 85 });
+      this.logger.info("SHOT_INFOBOX", "OK", `(${timeSpend()})`);
+      await page.close();
+      return import_koishi.h.image(img, "image/jpeg");
+    } catch (e) {
+      this.logger.warn("SHOT_INFOBOX", "Failed during screenshot", e);
+      await page?.close();
+      return "";
+    }
+  }
+  createInjectStylesFromDefinition({
+    selector,
+    injectStyles
+  }) {
+    const selectorString = Array.isArray(selector) ? selector.join(", ") : selector;
+    return `
+      body > *:not(#content),
+      #mw-navigation,
+      #mw-page-base,
+      #mw-head-base,
+      .mw-indicators {
+        display: none !important;
+      }
+      html, body, #content, .mw-parser-output {
+        visibility: visible !important;
+        background: white !important;
+        min-height: auto !important;
+      }
+      .mw-parser-output > *:not(${selectorString}) {
+         visibility: hidden;
+      }
+      ${selectorString}, ${selectorString} * {
+        visibility: visible;
+      }
+      ${injectStyles || ""}
+    `;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  name
+});
+/**
+ * koishi-plugin-mediawiki
+ * @desc MediaWiki plugin for Koishijs
+ * @author Koishijs(机智的小鱼君) <dragon-fish@qq.com>
+ * @license Apache-2.0
+ */

package/lib/infoboxes.d.ts

@@ -0,0 +1,5 @@
+import { InfoboxDefinition } from './types/Infobox';
+/**
+ * 内置匹配表，开发者也可以自己扩展该表
+ */
+export declare const INFOBOX_DEFINITION: InfoboxDefinition[];

package/lib/types/Config.d.ts

@@ -0,0 +1,9 @@
+import { InfoboxDefinition } from './Infobox';
+export interface Config {
+    cmdAuthWiki: number;
+    cmdAuthConnect: number;
+    cmdAuthSearch: number;
+    searchIfNotExist: boolean;
+    showDetailsByDefault: boolean;
+    customInfoboxes: InfoboxDefinition[];
+}

package/lib/types/Infobox.d.ts

@@ -0,0 +1,6 @@
+export interface InfoboxDefinition {
+    match: (url: URL) => boolean | string;
+    selector: string | string[];
+    injectStyles?: string;
+    skin?: string;
+}

package/lib/types/MediaWiki.d.ts

@@ -0,0 +1,83 @@
+export type MWPages = MWPage[];
+export interface MWPage {
+    pageid: number;
+    ns: number;
+    title: string;
+    extract: string;
+    contentmodel: string;
+    pagelanguage: string;
+    pagelanguagehtmlcode: string;
+    pagelanguagedir: string;
+    touched: string;
+    lastrevid: number;
+    length: number;
+    fullurl: string;
+    editurl: string;
+    canonicalurl: string;
+    displaytitle: string;
+    special?: boolean;
+    invalid?: boolean;
+    invalidreason?: string;
+    missing?: boolean;
+}
+export type MWRedirects = MWRedirect[];
+export interface MWRedirect {
+    from: string;
+    to: string;
+    tofragment?: string;
+}
+export type MWInterwikiLinks = MWInterwiki[];
+export interface MWInterwiki {
+    title: string;
+    iw: string;
+    url: string;
+}
+export type MWSpecialPageAliases = MWSpecialPageAlias[];
+export interface MWSpecialPageAlias {
+    realname: string;
+    aliases: string[];
+}
+export type MWNamespaceAliases = MWNamespaceAlias[];
+export interface MWNamespaceAlias {
+    id: number;
+    alias: string;
+}
+export type MWNamespaces = Record<string, MWNamespace>;
+export interface MWNamespace {
+    id: number;
+    case: string;
+    name: string;
+    subpages: boolean;
+    canonical: string;
+    content: boolean;
+    nonincludable: boolean;
+}
+export interface MWApiResponseQueryPagesWithSiteinfo {
+    query: {
+        pages: MWPages;
+        redirects?: MWRedirects;
+        interwiki?: MWInterwikiLinks;
+        specialpagealiases: MWSpecialPageAliases;
+        namespacealiases: MWNamespaceAliases;
+        namespaces: MWNamespaces;
+    };
+}
+export interface MWApiResponsQueryPagesGeneratedBySearch {
+    query: {
+        searchinfo: {
+            totalhits: number;
+        };
+        pages: {
+            pageid: number;
+            ns: number;
+            title: string;
+            index: number;
+            extract: string;
+        }[];
+        search: {
+            ns: number;
+            title: string;
+            pageid: number;
+        }[];
+    };
+}

package/lib/utils/BulkMessageBuilder.d.ts

@@ -0,0 +1,14 @@
+import { Session, Universal, h } from 'koishi';
+type MsgUser = Omit<Universal.User & Universal.GuildMember, 'id'>;
+export declare class BulkMessageBuilder {
+    #private;
+    session: Session;
+    constructor(session: Session);
+    all(): h;
+    get figure(): h;
+    addLine(author: MsgUser, message: string): this;
+    botSay(msg: string): this;
+    authorSay(msg: string): this;
+    prependOriginal(): this;
+}
+export {};

package/lib/utils/resolveBrackets.d.ts

@@ -0,0 +1 @@
+export declare function resolveBrackets(str: string): string;

package/lib/utils/wiki.d.ts

@@ -0,0 +1,7 @@
+import { MediaWikiApi } from 'wiki-saikou';
+export declare function useApi(baseURL: string): MediaWikiApi;
+export declare function getWikiTitleDBKey(raw: string): string;
+export declare function getWikiDisplayTitle(raw: string): string;
+export declare function parseTitlesFromText(str: string): string[];
+export declare function getUrl(base: string, params?: {}, script?: string): string;
+export declare function isValidApi(api: string | URL): boolean;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "koishi-plugin-mediawiki-fix",
+  "description": "Koishi.js 的 MediaWiki 插件，将您的群聊与 wiki 站点紧密连接！(修复版)",
+  "version": "0.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "license": "MIT",
+  "scripts": {},
+  "dependencies": {
+    "tslib": "^2.7.0",
+    "wiki-saikou": "^3.4.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.6.1",
+    "@typescript-eslint/eslint-plugin": "^8.7.0",
+    "@typescript-eslint/parser": "^8.7.0",
+    "eslint": "^9.11.1",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "koishi": "^4.18.0",
+    "koishi-plugin-puppeteer": "^3.9.0",
+    "prettier": "^3.3.3",
+    "typescript": "^5.6.2"
+  },
+  "peerDependencies": {
+    "koishi": "^4.18.0",
+    "koishi-plugin-puppeteer": "^3.9.0"
+  },
+  "repository": "https://github.com/koishijs/koishi-plugin-mediawiki",
+  "keywords": [
+    "koishi",
+    "koishi-plugin",
+    "mediawiki",
+    "mediawiki-bot",
+    "mediawiki-api",
+    "subscribe",
+    "chatbot"
+  ]
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-mediawiki-fix
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-mediawiki-fix?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-mediawiki-fix)
+
+Koishi.js 的 MediaWiki 插件，将您的群聊与 wiki 站点紧密连接！(修复版)