@dsh-plugin/dsh-synapse 0.0.0-stage → 0.1.0-dev.41044228975

package/vendor/gugle-chat-bot/src/features/hermes/trigger.ts

@@ -0,0 +1,86 @@
+import { ApprovalChoice } from '@/features/hermes/types';
+
+/**
+ * Hermes 触发判定与文本处理的纯函数（抽离自 HermesBridge 以便冒烟测试）。
+ */
+
+export interface GroupTriggerOptions {
+  /** 消息纯文本 */
+  text: string;
+  /** 是否 @了 bot */
+  mentioned: boolean;
+  /** 群聊中是否需要 @bot 才触发 */
+  requireMention: boolean;
+  /** 关键词触发列表（需已转小写） */
+  keywordTriggers: string[];
+}
+
+export interface TriggerDecision {
+  triggered: boolean;
+  reason?: string;
+}
+
+/**
+ * 群聊触发判定。
+ * 相对上游新增的守卫：以 / 或 ! 开头的消息视为命令（交给 gugle-command），
+ * 除非显式 @bot，否则不触发 AI，避免与命令系统双重响应。
+ */
+export function decideGroupTrigger(options: GroupTriggerOptions): TriggerDecision {
+  const text = options.text.trim();
+  if (options.mentioned) return { triggered: true, reason: 'mention' };
+  if (text.startsWith('/') || text.startsWith('!')) return { triggered: false };
+  const lower = text.toLowerCase();
+  for (const keyword of options.keywordTriggers) {
+    if (lower.includes(keyword)) return { triggered: true, reason: `keyword:${keyword}` };
+  }
+  if (!options.requireMention) return { triggered: true, reason: 'bare' };
+  return { triggered: false };
+}
+
+/**
+ * 解析审批回复文本为审批选择。
+ * 注意匹配顺序：始终允许 > 本次允许 > 拒绝 > 批准——
+ * 「不允许/不批准」包含「允许/批准」，上游先匹配批准导致否定词不可达，此处修正。
+ */
+export function parseApprovalChoice(text: string): ApprovalChoice | null {
+  const lower = text.toLowerCase().trim();
+  if (['始终允许', 'always', '始终批准', '全部允许'].some(keyword => lower.includes(keyword))) return 'always';
+  if (['本次允许', 'session'].some(keyword => lower.includes(keyword))) return 'session';
+  if (['拒绝', 'deny', '不批准', '不允许'].some(keyword => lower.includes(keyword))) return 'deny';
+  if (['批准', '通过', 'approve', 'ok', '允许'].some(keyword => lower.includes(keyword))) return 'once';
+  return null;
+}
+
+/** 按最大长度切分消息（优先在换行/空格处断开） */
+export function splitMessageText(text: string, maxLength: number): string[] {
+  if (maxLength <= 0 || text.length <= maxLength) return [text];
+  const chunks: string[] = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitIndex = remaining.lastIndexOf('\n', maxLength);
+    if (splitIndex < maxLength * 0.3) {
+      splitIndex = remaining.lastIndexOf(' ', maxLength);
+    }
+    if (splitIndex < maxLength * 0.3) {
+      splitIndex = maxLength;
+    }
+    chunks.push(remaining.slice(0, splitIndex));
+    remaining = remaining.slice(splitIndex).trimStart();
+  }
+  return chunks;
+}
+
+/** 判断文本是否为停止指令 */
+export function isStopCommand(text: string): boolean {
+  return text === '停止' || text.toLowerCase() === 'stop';
+}
+
+/** 判断文本是否为清除上下文指令 */
+export function isResetCommand(text: string): boolean {
+  const lower = text.toLowerCase();
+  return text === '清除上下文' || text === '新对话' || lower === 'new' || lower === 'reset';
+}

package/vendor/gugle-chat-bot/src/features/hermes/types.ts

@@ -0,0 +1,327 @@
+/**
+ * Hermes 桥接类型定义（移植自 qq-hermes-bridge src/types.d.ts，MIT 协议，原作者 Amorter）。
+ * OneBot 消息段类型复用 @/type，此处只保留 Hermes API / 会话 / 审批 / 技能相关类型。
+ */
+
+import type { QQBot } from '@/index';
+
+// ── 路由 ──
+
+/**
+ * Discord 路由的发送委托（由 DiscordBridge 注入，随 RouteInfo 传递）。
+ * HermesBridge 不直接持有 discord.js Client，经委托向原频道发送回复/图片。
+ */
+export interface DiscordRouteContext {
+  guildName: string;
+  channelName: string;
+  /** 发送者是否为 Discord 侧管理员（服务器拥有者/管理服务器/管理员权限） */
+  isAdmin: boolean;
+  /** 发送文本；quote=true 时首条引用原始消息 */
+  send(text: string, quote: boolean): Promise<void>;
+  /** 发送 base64 图片（Discord 附件） */
+  sendImage(base64: string): Promise<void>;
+  /** 摘除机器人对触发消息的「处理中」表情回应（由 DiscordBridge 注入，绑定原消息） */
+  removeReaction?(): Promise<void>;
+}
+
+/** handleDiscordMessage 的调用参数（DiscordRouteContext + 消息元信息） */
+export interface DiscordChatParams extends DiscordRouteContext {
+  /** 该频道桥接的 QQ 群号（会话共享与启用门控） */
+  groupId: string;
+  /** bot 的 Discord 用户 ID（@提及检测与剔除） */
+  botUserId?: string;
+}
+
+/** 消息来源路由：QQ 群聊、QQ 私聊或 Discord 频道 */
+export interface RouteInfo {
+  type: 'group' | 'user' | 'discord';
+  /** QQ 群号；discord 路由为桥接的 QQ 群号（与 QQ 群共享会话上下文） */
+  groupId?: string;
+  /** QQ 号字符串；discord 路由为 `dc:<Discord用户ID>` */
+  userId: string;
+  /** discord 路由：频道 ID */
+  channelId?: string;
+  /** discord 路由：发送委托（DiscordBridge 注入） */
+  discord?: DiscordRouteContext;
+}
+
+// ── 会话 ──
+
+/** 对话历史条目 */
+export interface HistoryEntry {
+  role: string;
+  content: string;
+  /** 发言人（user 消息）或回复对象（assistant 消息）的用户 id */
+  userId?: string;
+  /** assistant 消息回复对象的发送者标签（用于在历史中标注「你回复 xxx 的话」） */
+  label?: string;
+}
+
+/** 对话会话 */
+export interface Session {
+  history: HistoryEntry[];
+  sessionVersion: number;
+}
+
+// ── 运行状态 ──
+
+/** 活跃运行中的工具调用记录 */
+export interface RunToolRecord {
+  name: string;
+  duration: number;
+  error: boolean;
+  preview?: string;
+}
+
+/** 活跃运行中正在执行的工具 */
+export interface RunCurrentTool {
+  name: string;
+  preview?: string;
+  startedAt: number;
+}
+
+/** 活跃的 Hermes 运行状态 */
+export interface RunState {
+  route: RouteInfo;
+  tools: RunToolRecord[];
+  currentTool: RunCurrentTool | null;
+  startedAt: number;
+  lastProgressSent: number;
+  sendingProgress: boolean;
+  messageDelta: string;
+  pendingText: string;
+  sentTextLength: number;
+  lastTextSent: number;
+  finalOutput: string;
+  userMsgId: number;
+  /** 本轮对话发送者的展示标签（assistant 历史据此标注回复对象） */
+  senderLabel: string;
+  /** 工具结果回喂轮次（0 = 用户消息首轮；达上限后查询结果不再回喂，直接附在回复里） */
+  feedbackDepth?: number;
+  /** 「处理中」表情回应的持久化记录键（回喂轮转移给下一轮，对话链完全结束时摘除） */
+  reactionKey?: string;
+  /** 本轮是否已经贴过引用（逐句发送时只有首条单元贴引用，避免每条都重复引用） */
+  replySent?: boolean;
+  /** 本轮是否以 run.failed 结束（失败文案必须发出，不因已逐句下发而跳过） */
+  failed?: boolean;
+  /** 私聊文字回执的消息 id（AI 开始回复时撤回；QQ 表情回应失败时的降级方案） */
+  receiptId?: number;
+  /** 回执是否已转移给查询技能的回喂轮（转移后由下一轮负责撤回） */
+  receiptTransferred?: boolean;
+  /**
+   * 发送串行链：所有逐句/尾段发送都挂到这条链上按序执行。
+   * message.delta 的 flush 是 fire-and-forget，若并发执行会互相插队，
+   * 导致分条消息顺序错乱（后一批的句子插到前一批未发完的句子之前）。
+   */
+  sendChain?: Promise<void>;
+  stream?: { abort(): void };
+}
+
+// ── 审批 ──
+
+/** 待审批记录 */
+export interface Approval {
+  runId: string;
+  route: RouteInfo;
+  data: HermesApprovalEvent;
+  createdAt: number;
+  timeoutTimer?: ReturnType<typeof setTimeout>;
+}
+
+/** 审批选择 */
+export type ApprovalChoice = 'once' | 'deny' | 'always' | 'session';
+
+// ── Hermes SSE 事件类型 ──
+
+export interface HermesToolStartedEvent {
+  event: 'tool.started';
+  run_id: string;
+  timestamp: number;
+  tool: string;
+  preview?: string;
+}
+
+export interface HermesToolCompletedEvent {
+  event: 'tool.completed';
+  run_id: string;
+  timestamp: number;
+  tool: string;
+  duration: number;
+  error: boolean;
+}
+
+export interface HermesMessageDeltaEvent {
+  event: 'message.delta';
+  run_id: string;
+  timestamp: number;
+  delta: string;
+}
+
+export interface HermesApprovalEvent {
+  event: 'approval.request';
+  run_id: string;
+  timestamp: number;
+  command: string;
+  pattern_key?: string;
+  description?: string;
+}
+
+export interface HermesRunCompletedEvent {
+  event: 'run.completed';
+  run_id: string;
+  timestamp: number;
+  output: string;
+}
+
+export interface HermesRunFailedEvent {
+  event: 'run.failed';
+  run_id: string;
+  timestamp: number;
+  error: string;
+}
+
+export interface HermesReasoningEvent {
+  event: 'reasoning.available';
+  run_id: string;
+  timestamp: number;
+  text: string;
+}
+
+/** Hermes SSE 事件联合类型 */
+export type HermesSSEEvent =
+  | HermesToolStartedEvent
+  | HermesToolCompletedEvent
+  | HermesMessageDeltaEvent
+  | HermesApprovalEvent
+  | HermesRunCompletedEvent
+  | HermesRunFailedEvent
+  | HermesReasoningEvent;
+
+/** Hermes SSE 事件回调映射 */
+export interface HermesEventCallbacks {
+  'tool.started'?: (ev: HermesToolStartedEvent) => void;
+  'tool.completed'?: (ev: HermesToolCompletedEvent) => void;
+  'message.delta'?: (ev: HermesMessageDeltaEvent) => void;
+  'approval.request'?: (ev: HermesApprovalEvent) => void;
+  'run.completed'?: (ev: HermesRunCompletedEvent) => void;
+  'run.failed'?: (ev: HermesRunFailedEvent) => void;
+  'reasoning.available'?: (ev: HermesReasoningEvent) => void;
+  _end?: () => void;
+  _error?: (err: Error) => void;
+  _any?: (ev: HermesSSEEvent) => void;
+}
+
+// ── 技能系统 ──
+
+/** 群管理 API 门面（由 HermesBridge 基于 QQBot 实现后注入技能） */
+export interface GroupAdminApi {
+  /** 禁言群成员（durationSec=0 解除） */
+  setGroupBan(groupId: string, userId: string, durationSec: number): Promise<unknown>;
+  /** 踢出群成员 */
+  setGroupKick(groupId: string, userId: string): Promise<unknown>;
+  /** 开启/关闭全员禁言 */
+  setGroupWholeBan(groupId: string, enable: boolean): Promise<unknown>;
+}
+
+/** 技能执行上下文 */
+export interface SkillExecuteContext {
+  /** QQBot 实例（卡片类技能经其 axiosInstance/logger 访问外部 API 与渲染） */
+  bot: QQBot;
+  api: GroupAdminApi;
+  route: RouteInfo;
+  args: string[];
+}
+
+/**
+ * 技能执行产出：纯文本摘要字符串，或 `{ message, images }`——
+ * images 为待发送的 base64 图片（允许带 base64:// 前缀），由完成处理器逐张发出。
+ */
+export type SkillExecution = string | { message: string; images?: string[] };
+
+/** 技能定义 */
+export interface Skill {
+  name: string;
+  usage: string;
+  description: string;
+  adminOnly: boolean;
+  /**
+   * true：查询类技能——执行结果不作为摘要发给用户，而是回喂给 AI 整理回答
+   * （完成处理器会把结果以 [工具结果] 输入再提交一轮 run，有防循环上限）；
+   * false/缺省：动作/卡片类——执行摘要附加到回复文本后直接发出。
+   */
+  feedback?: boolean;
+  execute(ctx: SkillExecuteContext): Promise<SkillExecution>;
+}
+
+/** 查询类技能的回喂数据 */
+export interface SkillFeedback {
+  skill: string;
+  data: string;
+}
+
+/** 技能执行结果 */
+export type SkillResult =
+  | { ok: true; skill: string; message: string; images?: string[] }
+  | { ok: false; skill: string; error: string };
+
+/** processTags 的返回：清理后的文本 + 全部技能产出的图片 + 查询类技能的回喂数据 */
+export interface ProcessedSkillOutput {
+  text: string;
+  images: string[];
+  feedback: SkillFeedback[];
+}
+
+// ── 多模态消息内容 ──
+
+/** OpenAI 风格消息内容段（用于多模态 user_message） */
+export type MessageContentPart = { type: 'text'; text: string } | { type: 'image_url'; image_url: { url: string } };
+
+/** formatMessage 的返回：文本 + 提取到的图片列表（均为 base64 data URL） */
+export interface FormattedMessage {
+  text: string;
+  /** base64 data URL（data:image/...;base64,...） */
+  images: string[];
+}
+
+// ── OneBot API 响应（功能内使用的最小子集） ──
+
+/** get_msg API 返回值 */
+export interface OneBotGetMsgResponse {
+  message_id: number;
+  sender: {
+    user_id: number;
+    nickname: string;
+  };
+  time: number;
+  message: import('@/type').Message[];
+}
+
+/** get_forward_msg 节点（兼容 NapCat node 格式与 go-cqhttp 旧格式） */
+export interface OneBotForwardNode {
+  type?: 'node';
+  data?: {
+    user_id?: number;
+    nickname?: string;
+    card?: string;
+    time?: number;
+    message?: import('@/type').Message[];
+    content?: import('@/type').Message[] | string;
+  };
+  sender?: { user_id?: number; nickname?: string; card?: string };
+  time?: number;
+  content?: import('@/type').Message[] | string;
+}
+
+/** get_forward_msg API 返回值 */
+export interface OneBotGetForwardMsgResponse {
+  messages: OneBotForwardNode[];
+}
+
+/** get_group_member_info API 返回值 */
+export interface OneBotGroupMemberInfo {
+  group_id: number;
+  user_id: number;
+  nickname: string;
+  card: string;
+  role: string;
+}

package/vendor/gugle-chat-bot/src/features/management/index.ts

@@ -0,0 +1,156 @@
+import { QQBot } from '@/index';
+import { GroupDecreaseNoticeWSMSG, GroupIncreaseNoticeWSMSG, GroupRequestWSMSG } from '@/type';
+import { EventDataManager } from '@/event';
+import { getFeatureConfig } from '@/config/features';
+
+function handleGroupDecreaseNotice(bot: QQBot, msg: GroupDecreaseNoticeWSMSG) {
+  if (!getFeatureConfig('management').groups.includes(msg.group_id)) return;
+  EventDataManager.getStorage('management', 'ban_list').then(raw => {
+    // 归一化后再判重：兼容历史字符串条目，避免同一用户被写成两份（数字 + 字符串）
+    const banList = Management.normalizeBanList(raw);
+    const userId = Number(msg.user_id);
+    if (!Number.isSafeInteger(userId) || userId <= 0) return;
+    // 已归一化集合里存在即视为已拉黑；顺带把归一化结果写回，清理历史脏数据
+    const alreadyBanned = banList.includes(userId);
+    if (alreadyBanned && JSON.stringify(banList) === JSON.stringify(raw)) return;
+    if (!alreadyBanned) banList.push(userId);
+    EventDataManager.setStorage('management', 'ban_list', banList).then(() => {
+      if (alreadyBanned) return; // 仅做数据清理，不再重复播报
+      const reason = msg.sub_type === 'kick' ? '被管理员移出群聊' : '退出群聊';
+      bot.getUserInfo(msg.user_id).then(userInfo => {
+        bot.sendGroupMsg(msg.group_id, [
+          {
+            type: 'text',
+            data: {
+              text: `用户 ${userInfo.nickname}(${userInfo.user_id}) 已${reason}，现已加入黑名单，将自动拒绝后续加群申请！`
+            }
+          }
+        ]);
+      });
+    });
+  });
+}
+
+function handleGroupIncreaseNotice(bot: QQBot, msg: GroupIncreaseNoticeWSMSG) {
+  if (!getFeatureConfig('management').groups.includes(msg.group_id)) return;
+  EventDataManager.getStorage('management', 'ban_list').then(raw => {
+    const banList = Management.normalizeBanList(raw);
+    const userId = Number(msg.user_id);
+    if (!banList.includes(userId)) return;
+    if (msg.sub_type === 'invite' && getFeatureConfig('management').operators?.includes(msg.operator_id)) {
+      // 管理员主动邀请 = 视为赦免：移出黑名单
+      EventDataManager.setStorage(
+        'management',
+        'ban_list',
+        banList.filter(id => id !== userId)
+      ).then();
+      return;
+    }
+    bot.kick(msg.group_id, msg.user_id);
+    bot.getUserInfo(msg.user_id).then(userInfo => {
+      bot.sendGroupMsg(msg.group_id, [
+        {
+          type: 'text',
+          data: {
+            text: `黑名单用户 ${userInfo.nickname}(${userInfo.user_id}) 加群，已自动移出！`
+          }
+        }
+      ]);
+    });
+  });
+}
+
+function handleGroupRequest(bot: QQBot, msg: GroupRequestWSMSG) {
+  if (!getFeatureConfig('management').groups.includes(msg.group_id)) return;
+  if (msg.sub_type !== 'add') return;
+  EventDataManager.getStorage('management', 'ban_list').then(raw => {
+    const banList = Management.normalizeBanList(raw);
+    if (!banList.includes(Number(msg.user_id))) return;
+    bot.denyGroupAddRequest(msg.flag, '你已被拉入黑名单，系统自动拒绝！');
+    bot.getUserInfo(msg.user_id).then(userInfo => {
+      bot.sendGroupMsg(msg.group_id, [
+        {
+          type: 'text',
+          data: {
+            text: `黑名单用户 ${userInfo.nickname}(${userInfo.user_id}) 申请加群，已自动拒绝！`
+          }
+        }
+      ]);
+    });
+  });
+}
+
+export class Management {
+  public static handleGroupDecreaseNotice(bot: QQBot, msg: GroupDecreaseNoticeWSMSG) {
+    handleGroupDecreaseNotice(bot, msg);
+  }
+
+  public static handleGroupIncreaseNotice(bot: QQBot, msg: GroupIncreaseNoticeWSMSG) {
+    handleGroupIncreaseNotice(bot, msg);
+  }
+
+  public static handleGroupRequest(bot: QQBot, msg: GroupRequestWSMSG) {
+    handleGroupRequest(bot, msg);
+  }
+
+  /**
+   * /pardon <QQ号>：把用户从黑名单移除（赦免）。
+   * 仅限 management 功能启用的群 + 管理员使用。
+   *
+   * 权限校验（**全部在此处完成**，不依赖调用方）：
+   * - QQ 侧 operatorId 为 number → 必须在 management.json `operators` 白名单内；
+   * - Discord 侧 operatorId 为 `dc:<用户ID>` → 必须是 management.json `discordOperators`
+   *   白名单成员。注意：此前仅校验 `dc:` 前缀即放行，导致被桥接频道里任意成员都能赦免黑名单用户。
+   *
+   * @returns true=已移除；false=不在黑名单/无权限
+   */
+  public static async pardon(groupId: number, operatorId: number | string, userId: number): Promise<boolean> {
+    const config = getFeatureConfig('management');
+    if (!config.groups.includes(groupId)) return false;
+    if (!this.isOperatorAllowed(operatorId)) return false;
+
+    // 黑名单历史数据/不同 OneBot 实现可能写入字符串形态的 QQ 号，
+    // 统一按数值比较，避免「明明在黑名单里却删不掉」。
+    const banList = this.normalizeBanList(await EventDataManager.getStorage('management', 'ban_list'));
+    if (!banList.includes(userId)) return false;
+
+    const next = banList.filter(id => id !== userId);
+    await EventDataManager.setStorage('management', 'ban_list', next);
+    return true;
+  }
+
+  /**
+   * 操作者是否有权执行管理操作。
+   *
+   * - number（QQ 号）→ operators 白名单；
+   * - `dc:` 前缀 → discordOperators 白名单（必须是显式配置的用户）；
+   * - 其他形态 → 拒绝。
+   */
+  public static isOperatorAllowed(operatorId: number | string): boolean {
+    const config = getFeatureConfig('management');
+    if (typeof operatorId === 'number') {
+      return config.operators?.includes(operatorId) ?? false;
+    }
+    if (typeof operatorId === 'string' && /^dc:/i.test(operatorId)) {
+      const target = operatorId.slice(3).trim();
+      if (!target) return false;
+      return (config.discordOperators ?? []).some(item => item.replace(/^dc:/i, '').trim() === target);
+    }
+    return false;
+  }
+
+  /**
+   * 归一化黑名单：字符串数字转 number、剔除非法项、去重。
+   * 兼容历史脏数据（如被写成 `"2017065007"` 的条目），避免「明明在黑名单里却删不掉」。
+   */
+  public static normalizeBanList(raw: unknown): number[] {
+    if (!Array.isArray(raw)) return [];
+    const result: number[] = [];
+    for (const item of raw) {
+      const value = typeof item === 'string' ? Number(item.trim()) : item;
+      if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0) continue;
+      if (!result.includes(value)) result.push(value);
+    }
+    return result;
+  }
+}

package/vendor/gugle-chat-bot/src/features/minecraft/index.ts

@@ -0,0 +1,127 @@
+import axios, { AxiosResponse } from 'axios';
+import { JSDOM } from 'jsdom';
+
+export declare type Version = {
+  success: boolean;
+  latest: {
+    release: string;
+    snapshot: string;
+  };
+  versions: {
+    id: string;
+    type: string;
+    url: string;
+    time: string;
+    releaseTime: string;
+    sha1: string;
+    complianceLevel: number;
+  }[];
+};
+
+export declare type MinecraftServerStatus = {
+  online: boolean;
+  version: string;
+  motd: string;
+  players: { online: number; max: number; list: string[] };
+};
+
+export declare type WikiResult = {
+  success: boolean;
+  url: string;
+  title: string;
+  desc: string;
+};
+
+export class MinecraftAPI {
+  private static readonly VERSION_MANIFEST_URL: string =
+    'https://piston-meta.mojang.com/mc/game/version_manifest_v2.json';
+
+  public static async getVersion(): Promise<Version> {
+    try {
+      const res: AxiosResponse<{
+        latest: {
+          release: '';
+          snapshot: '';
+        };
+        versions: [];
+      }> = await axios.get(MinecraftAPI.VERSION_MANIFEST_URL);
+      return {
+        success: true,
+        ...res.data
+      };
+    } catch (_) {
+      return {
+        success: false,
+        latest: {
+          release: '',
+          snapshot: ''
+        },
+        versions: []
+      };
+    }
+  }
+
+  public static async getMinecraftServerStatus(ip: string, port?: number): Promise<MinecraftServerStatus> {
+    try {
+      if (ip.includes(':')) port = undefined;
+      const res: AxiosResponse = await axios.get(
+        `https://api.mcstatus.io/v2/status/java/${ip}${port ? ':' + port : ''}`
+      );
+      const result: MinecraftServerStatus = {
+        online: res.data.online,
+        version: res.data.version.name_clean,
+        motd: res.data.motd.clean,
+        players: {
+          online: res.data.players.online,
+          max: res.data.players.max,
+          list: []
+        }
+      };
+      for (const player of res.data.players.list as { name_clean: string }[]) {
+        result.players.list.push(player.name_clean);
+      }
+      return result;
+    } catch (e) {
+      return {
+        online: false,
+        version: '',
+        motd: '',
+        players: {
+          online: 0,
+          max: 0,
+          list: []
+        }
+      };
+    }
+  }
+
+  public static async getMinecraftWiki(keyword: string): Promise<WikiResult> {
+    try {
+      const res: AxiosResponse = await axios.get(`https://zh.minecraft.wiki/w/?search=${keyword}`);
+      const dom = new JSDOM(res.data);
+      const document = dom.window.document;
+      const content = document.getElementById('mw-content-text');
+      const result: WikiResult = {
+        success: !content?.getElementsByClassName('mw-search-nonefound').length || false,
+        url: res.request.res.responseUrl || '',
+        title: document.getElementById('firstHeading')?.textContent || '',
+        desc: ''
+      };
+      for (let child of content?.getElementsByClassName('mw-parser-output').item(0)?.children || []) {
+        if (child.id == 'toc') break;
+        if (child.tagName != 'P') continue;
+        if (!child.textContent) continue;
+        if (child.textContent == '\n' || child.textContent == '\\n') continue;
+        result.desc += '\r\n' + child.textContent.replace('\n', '').replace('\\n', '');
+      }
+      return result;
+    } catch (_) {
+      return {
+        success: false,
+        url: '',
+        title: '',
+        desc: ''
+      };
+    }
+  }
+}