koishi-plugin-oni-sync-bot 0.6.2 → 0.7.0

package/lib/index.js

@@ -32,15 +32,13 @@ var src_exports = {};
 __export(src_exports, {
   Config: () => Config,
   apply: () => apply,
-  inject: () => inject,
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi5 = require("koishi");
-var import_path = require("path");
-var import_plugin_console = require("@koishijs/plugin-console");
+var import_koishi11 = require("koishi");
 
-// src/utils/login.ts
+// src/services/wikiBotService.ts
+var import_koishi2 = require("koishi");
 var import_mwn = require("mwn");
 
 // src/utils/tools.ts
@@ -88,63 +86,335 @@ function generatePinyinInfo(text) {
   };
 }
 __name(generatePinyinInfo, "generatePinyinInfo");
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+__name(getErrorMessage, "getErrorMessage");
 var logger = new import_koishi.Logger("oni-sync");
 
-// src/utils/login.ts
-async function login(siteConfig) {
-  const bot = new import_mwn.Mwn({
-    apiUrl: siteConfig.api,
-    username: siteConfig.username,
-    password: siteConfig.password,
-    userAgent: siteConfig.userAgent,
-    defaultParams: {
-      assert: "user"
+// src/services/wikiBotService.ts
+var WikiBotService = class _WikiBotService extends import_koishi2.Service {
+  static {
+    __name(this, "WikiBotService");
+  }
+  static inject = [];
+  ggbot = null;
+  bwikibot = null;
+  isReady = false;
+  botConfig;
+  static USER_AGENT = `OniSyncBot/1.0 (https://klei.vip; Charles@klei.vip)`;
+  static MAX_RETRIES = 3;
+  static RETRY_DELAY = 5e3;
+  constructor(ctx, config) {
+    super(ctx, "wikiBot", true);
+    this.botConfig = config;
+  }
+  getSitesConfig() {
+    return {
+      gg: {
+        name: "WIKIGG",
+        api: "https://oxygennotincluded.wiki.gg/zh/api.php",
+        username: this.botConfig.ggUsername,
+        password: this.botConfig.ggPassword,
+        userAgent: _WikiBotService.USER_AGENT
+      },
+      bwiki: {
+        name: "bwiki",
+        api: "https://wiki.biligame.com/oni/api.php",
+        username: this.botConfig.bwikiusername,
+        password: this.botConfig.bwikipassword,
+        userAgent: _WikiBotService.USER_AGENT
+      }
+    };
+  }
+  delay(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+  async loginWithRetry(siteConfig, attempt = 1) {
+    try {
+      logger.info(
+        `正在登录 ${siteConfig.name}... (尝试 ${attempt}/${_WikiBotService.MAX_RETRIES})`
+      );
+      const bot = await this.login(siteConfig);
+      return bot;
+    } catch (error) {
+      const errorMsg = getErrorMessage(error);
+      if (attempt < _WikiBotService.MAX_RETRIES) {
+        logger.warn(
+          `登录 ${siteConfig.name} 失败，${_WikiBotService.RETRY_DELAY / 1e3}秒后重试...`,
+          errorMsg
+        );
+        await this.delay(_WikiBotService.RETRY_DELAY);
+        return this.loginWithRetry(siteConfig, attempt + 1);
+      }
+      logger.error(
+        `登录 ${siteConfig.name} 失败，已达到最大重试次数`,
+        errorMsg
+      );
+      throw error;
     }
-  });
-  if (siteConfig.name === "bwiki") {
-    const cookieString = "SESSDATA=666; Domain=wiki.biligame.com; Path=/oni; HttpOnly; Secure;";
-    bot.cookieJar.setCookie(cookieString, bot.options.apiUrl, (err) => {
-      if (err) console.error("Cookie 注入失败：", err);
+  }
+  async login(siteConfig) {
+    logger.info(`正在连接 ${siteConfig.name} API: ${siteConfig.api}`);
+    const bot = new import_mwn.Mwn({
+      apiUrl: siteConfig.api,
+      username: siteConfig.username,
+      password: siteConfig.password,
+      userAgent: siteConfig.userAgent,
+      defaultParams: {
+        assert: "user"
+      },
+      maxRetries: 0,
+      retryPause: 0
     });
-    bot.setRequestOptions({
-      headers: {
-        referer: "https://wiki.biligame.com/oni/"
+    if (siteConfig.name === "bwiki") {
+      const cookieString = "SESSDATA=666; Domain=wiki.biligame.com; Path=/oni; HttpOnly; Secure;";
+      bot.cookieJar.setCookie(cookieString, bot.options.apiUrl, (err) => {
+        if (err) {
+          logger.warn("Cookie 注入失败:", err);
+        } else {
+          logger.info("Cookie 注入成功");
+        }
+      });
+      bot.setRequestOptions({
+        headers: {
+          referer: "https://wiki.biligame.com/oni/",
+          "User-Agent": siteConfig.userAgent
+        }
+      });
+    }
+    logger.info(`正在执行 ${siteConfig.name} 登录...`);
+    await bot.login();
+    logger.info(`✅ 成功登录 ${siteConfig.name}`);
+    return bot;
+  }
+  async start() {
+    logger.info("WikiBotService 正在初始化...");
+    try {
+      const sitesConfig = this.getSitesConfig();
+      logger.info("开始登录 WIKIGG...");
+      try {
+        this.ggbot = await this.loginWithRetry(sitesConfig.gg);
+      } catch (error) {
+        const errorMsg = getErrorMessage(error);
+        logger.error(
+          "WIKIGG 登录失败，服务将继续运行，但 WIKIGG 相关功能不可用",
+          errorMsg
+        );
+      }
+      logger.info("开始登录 bwiki...");
+      try {
+        this.bwikibot = await this.loginWithRetry(sitesConfig.bwiki);
+      } catch (error) {
+        const errorMsg = getErrorMessage(error);
+        logger.error(
+          "bwiki 登录失败，服务将继续运行，但 bwiki 相关功能不可用",
+          errorMsg
+        );
+      }
+      if (this.ggbot && this.bwikibot) {
+        this.isReady = true;
+        logger.info("WikiBotService 初始化成功，两个 Wiki 已登录");
+      } else if (this.ggbot || this.bwikibot) {
+        this.isReady = true;
+        logger.warn(
+          `WikiBotService 部分初始化成功，已登录: ${this.ggbot ? "WIKIGG" : ""} ${this.bwikibot ? "bwiki" : ""}`
+        );
+      } else {
+        logger.error("WikiBotService 初始化失败，所有登录都失败");
       }
+    } catch (error) {
+      const errorMsg = getErrorMessage(error);
+      logger.error("WikiBotService 初始化出错:", errorMsg);
+    }
+  }
+  stop() {
+    this.isReady = false;
+    this.ggbot = null;
+    this.bwikibot = null;
+    logger.info("WikiBotService 已停止");
+  }
+  async relogin() {
+    const sitesConfig = this.getSitesConfig();
+    let ggSuccess = false;
+    let bwikiSuccess = false;
+    logger.info("开始重新登录 WIKIGG...");
+    try {
+      this.ggbot = await this.loginWithRetry(sitesConfig.gg);
+      ggSuccess = true;
+      logger.info("✅ 成功重新登录 WIKIGG");
+    } catch (error) {
+      this.ggbot = null;
+      const errorMsg = getErrorMessage(error);
+      logger.error("❌ 重新登录 WIKIGG 失败", errorMsg);
+    }
+    logger.info("开始重新登录 bwiki...");
+    try {
+      this.bwikibot = await this.loginWithRetry(sitesConfig.bwiki);
+      bwikiSuccess = true;
+      logger.info("✅ 成功重新登录 bwiki");
+    } catch (error) {
+      this.bwikibot = null;
+      const errorMsg = getErrorMessage(error);
+      logger.error("❌ 重新登录 bwiki 失败", errorMsg);
+    }
+    if (this.ggbot && this.bwikibot) {
+      this.isReady = true;
+      logger.info("WikiBotService 重新登录成功，两个 Wiki 已登录");
+    } else if (this.ggbot || this.bwikibot) {
+      this.isReady = true;
+      logger.warn(
+        `WikiBotService 部分重新登录成功，已登录: ${this.ggbot ? "WIKIGG" : ""} ${this.bwikibot ? "bwiki" : ""}`
+      );
+    } else {
+      this.isReady = false;
+      logger.error("WikiBotService 重新登录失败，所有登录都失败");
+    }
+    return { gg: ggSuccess, bwiki: bwikiSuccess };
+  }
+  isGGBotReady() {
+    return this.ggbot !== null;
+  }
+  isBWikiBotReady() {
+    return this.bwikibot !== null;
+  }
+  getGGBot() {
+    if (!this.ggbot) {
+      throw new Error("WIKIGG bot 尚未就绪，请检查登录配置或查看日志");
+    }
+    return this.ggbot;
+  }
+  getBWikiBot() {
+    if (!this.bwikibot) {
+      throw new Error("bwiki bot 尚未就绪，请检查登录配置或查看日志");
+    }
+    return this.bwikibot;
+  }
+};
+((WikiBotService2) => {
+  WikiBotService2.Config = import_koishi2.Schema.object({
+    ggUsername: import_koishi2.Schema.string().description("WIKIGG 用户名").default("1"),
+    ggPassword: import_koishi2.Schema.string().description("WIKIGG 密码").default("1"),
+    bwikiusername: import_koishi2.Schema.string().description("bwiki用户名").default("1"),
+    bwikipassword: import_koishi2.Schema.string().description("bwiki密码").default("1")
+  });
+})(WikiBotService || (WikiBotService = {}));
+
+// src/plugins/consoleLogProvider.ts
+var import_koishi3 = require("koishi");
+var import_plugin_console = require("@koishijs/plugin-console");
+var import_path = require("path");
+var logBuffer = [];
+var PublicLogProvider = class extends import_plugin_console.DataService {
+  static {
+    __name(this, "PublicLogProvider");
+  }
+  constructor(ctx) {
+    super(ctx, "onilogs", { authority: 0 });
+  }
+  async get() {
+    return logBuffer;
+  }
+};
+var ConsoleLogProvider = class {
+  static {
+    __name(this, "ConsoleLogProvider");
+  }
+  static inject = ["console"];
+  constructor(ctx) {
+    ctx.console.addEntry({
+      dev: (0, import_path.resolve)(__dirname, "../../client/index.ts"),
+      prod: (0, import_path.resolve)(__dirname, "../../dist")
+    });
+    ctx.plugin(PublicLogProvider);
+    const target = {
+      colors: 0,
+      record: /* @__PURE__ */ __name((record) => {
+        if (record.name !== "oni-sync") return;
+        logBuffer.push(record);
+        if (logBuffer.length > 1e3) {
+          logBuffer = logBuffer.slice(-1e3);
+        }
+        ctx.get("console")?.patch("onilogs", logBuffer);
+      }, "record")
+    };
+    import_koishi3.Logger.targets.push(target);
+    ctx.on("dispose", () => {
+      const index = import_koishi3.Logger.targets.indexOf(target);
+      if (index > -1) import_koishi3.Logger.targets.splice(index, 1);
     });
   }
-  await bot.login();
-  logger.info(`✅ 成功登录 ${siteConfig.name}`);
-  return bot;
-}
-__name(login, "login");
+};
 
-// src/config/index.ts
-var userAgent = `OniSyncBot/1.0 (https://klei.vip; Charles@klei.vip)`;
-function getSitesConfig(config) {
-  return {
-    gg: {
-      name: "WIKIGG",
-      api: "https://oxygennotincluded.wiki.gg/zh/api.php",
-      username: config.ggUsername,
-      password: config.ggPassword,
-      userAgent
-    },
-    bwiki: {
-      name: "bwiki",
-      api: "https://wiki.biligame.com/oni/api.php",
-      username: config.bwikiusername,
-      password: config.bwikipassword,
-      userAgent
-    }
-  };
-}
-__name(getSitesConfig, "getSitesConfig");
+// src/plugins/databaseExtension.ts
+var DatabaseExtension = class {
+  static {
+    __name(this, "DatabaseExtension");
+  }
+  static inject = ["database"];
+  constructor(ctx) {
+    ctx.model.extend("wikipages", {
+      id: "integer",
+      title: "string",
+      pinyin_full: "string",
+      pinyin_first: "string"
+    });
+  }
+};
+
+// src/plugins/routeRedirect.ts
+var import_koishi4 = require("koishi");
+var RouteRedirect = class {
+  static {
+    __name(this, "RouteRedirect");
+  }
+  static inject = ["database", "server"];
+  config;
+  constructor(ctx, config) {
+    this.config = config;
+    ctx.server.get("/gg/:id", async (router) => {
+      const pageId = Number(router.params.id);
+      if (isNaN(pageId)) return router.body = "❌ 无效的页面ID，必须为数字！";
+      const [page] = await ctx.database.get("wikipages", { id: pageId });
+      if (!page)
+        return router.body = `❌ 未找到ID为【${pageId}】的页面，请联系管理员更新缓存！`;
+      const targetUrl = `https://${this.config.main_site}/${encodeURIComponent(
+        page.title
+      )}?variant=zh`;
+      router.redirect(targetUrl);
+    });
+    ctx.server.get("/bw/:id", async (router) => {
+      const pageId = Number(router.params.id);
+      if (isNaN(pageId)) return router.body = "❌ 无效的页面ID，必须为数字！";
+      const [page] = await ctx.database.get("wikipages", { id: pageId });
+      if (!page)
+        return router.body = `❌ 未找到ID为【${pageId}】的页面，请联系管理员更新缓存！`;
+      const targetUrl = `https://${this.config.bwiki_site}/${encodeURIComponent(
+        page.title
+      )}`;
+      router.redirect(targetUrl);
+    });
+  }
+};
+((RouteRedirect2) => {
+  RouteRedirect2.Config = import_koishi4.Schema.object({
+    domain: import_koishi4.Schema.string().description("你的短链域名（必填，如：klei.vip）").default("klei.vip"),
+    main_site: import_koishi4.Schema.string().description("主站域名（必填，如：oxygennotincluded.wiki.gg）").default("oxygennotincluded.wiki.gg/zh"),
+    bwiki_site: import_koishi4.Schema.string().description("镜像站域名（必填，如：wiki.biligame.com）").default("wiki.biligame.com/oni")
+  });
+})(RouteRedirect || (RouteRedirect = {}));
+
+// src/plugins/syncCommands.ts
+var import_koishi8 = require("koishi");
 
 // src/sync/pageSync.ts
-var import_koishi3 = require("koishi");
+var import_koishi6 = require("koishi");
 
 // src/sync/imgSync.ts
-var import_koishi2 = require("koishi");
+var import_koishi5 = require("koishi");
 var import_node_fetch = __toESM(require("node-fetch"));
 var import_form_data = __toESM(require("form-data"));
 var CONFIG = {
@@ -174,11 +444,56 @@ async function getImageInfo(site, fileName) {
       size: imageInfo.size
     };
   } catch (error) {
-    logger.error(`[GetImageInfo] 获取 ${fileName} 信息失败:`, error);
+    const errorMsg = getErrorMessage(error);
+    logger.error(`[GetImageInfo] 获取 ${fileName} 信息失败:`, errorMsg);
     return null;
   }
 }
 __name(getImageInfo, "getImageInfo");
+async function deleteOldVersions(bot, fileName) {
+  try {
+    const response = await bot.query({
+      action: "query",
+      titles: fileName,
+      prop: "revisions",
+      rvprop: "ids|timestamp",
+      rvlimit: "max",
+      rvdir: "newer"
+      // 按时间正序排列，最新的在最后
+    });
+    const pages = response.query?.pages || {};
+    const page = Object.values(pages)[0];
+    if (!page || !page.revisions || page.revisions.length <= 1) {
+      return;
+    }
+    const revisionIds = page.revisions.slice(0, -1).map((rev) => rev.revid);
+    const token = await bot.getCsrfToken();
+    for (const revid of revisionIds) {
+      try {
+        await bot.rawRequest({
+          method: "POST",
+          url: bot.options.apiUrl,
+          data: {
+            action: "delete",
+            title: fileName,
+            revid,
+            token,
+            reason: "自动清理旧版本，只保留最新同步版本",
+            format: "json"
+          }
+        });
+        logger.info(`[SyncImg] 🗑️ 删除旧版本 ${revid} 成功`);
+      } catch (error) {
+        const errorMsg = getErrorMessage(error);
+        logger.error(`[SyncImg] ❌ 删除旧版本 ${revid} 失败:`, errorMsg);
+      }
+    }
+  } catch (error) {
+    const errorMsg = getErrorMessage(error);
+    logger.error(`[SyncImg] ❌ 获取版本信息失败:`, errorMsg);
+  }
+}
+__name(deleteOldVersions, "deleteOldVersions");
 async function syncSingleImage(sourceBot, targetBot, fileName, config) {
   if (CONFIG.IGNORED_IMAGES.includes(fileName)) {
     logger.info(`[SyncImg] 🚫 图片 ${fileName} 在忽略列表，跳过`);
@@ -193,7 +508,7 @@ async function syncSingleImage(sourceBot, targetBot, fileName, config) {
     }
     const targetImageInfo = await getImageInfo(targetBot, fileName);
     logger.info(`原图片sha1: ${sourceImageInfo.sha1}`);
-    logger.info(`目标图片sha1: ${targetImageInfo.sha1}`);
+    logger.info(`目标图片sha1: ${targetImageInfo?.sha1}`);
     if (targetImageInfo && targetImageInfo.sha1 === sourceImageInfo.sha1) {
       logger.info(`[SyncImg] 🟡 图片 ${fileName} 已存在且内容一致，跳过`);
       return { success: true, reason: "no_change" };
@@ -236,6 +551,7 @@ async function syncSingleImage(sourceBot, targetBot, fileName, config) {
     const responseData = rawResponse.data;
     if (responseData.upload && responseData.upload.result === "Success") {
       logger.info(`[SyncImg] ✅ 图片 ${fileName} 同步成功`);
+      await deleteOldVersions(targetBot, fileName);
       return { success: true, reason: "synced" };
     } else if (responseData.error) {
       throw new Error(`${responseData.error.code}: ${responseData.error.info}`);
@@ -303,13 +619,13 @@ async function syncAllImages(sourceBot, targetBot, config) {
       if (!result.success) {
         failCount++;
         failedImages.push(fileName);
-        await (0, import_koishi2.sleep)(CONFIG.SYNC_INTERVAL_FAILED);
+        await (0, import_koishi5.sleep)(CONFIG.SYNC_INTERVAL_FAILED);
       } else {
         successCount++;
         if (result.reason === "ignored" || result.reason === "no_change") {
           skipCount++;
         }
-        await (0, import_koishi2.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
+        await (0, import_koishi5.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
       }
     }
     if (failedImages.length > 0) {
@@ -335,7 +651,7 @@ async function syncAllImages(sourceBot, targetBot, config) {
           stillFailed.push(fileName);
           logger.info(`[SyncAllImg] ❌ 重试失败: ${fileName}`);
         }
-        await (0, import_koishi2.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
+        await (0, import_koishi5.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
       }
       if (stillFailed.length > 0) {
         logger.info(`
@@ -422,13 +738,13 @@ async function processPageWithStats(oldSite, newSite, pageTitle, user, stats, fa
   if (!syncResult.success) {
     stats.failCount++;
     failedPages.push(pageTitle);
-    await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+    await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
   } else {
     stats.successCount++;
     if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
       stats.skipCount++;
     }
-    await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+    await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
   }
 }
 __name(processPageWithStats, "processPageWithStats");
@@ -504,11 +820,11 @@ async function syncPages(oldSite, newSite) {
             stats.skipCount++;
           }
           logger.info(`[SyncAllPages] ✅ 页面 ${pageTitle} 重试成功`);
-          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+          await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
         } else {
           stillFailed.push(pageTitle);
           logger.info(`[SyncAllPages] ❌ 页面 ${pageTitle} 再次失败`);
-          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+          await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
         }
       }
     }
@@ -577,11 +893,11 @@ async function incrementalUpdate(oldSite, newSite, config) {
               CONFIG2.INCREMENTAL_USER
             );
           }
-          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+          await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
         } catch (error) {
           const errMsg = error instanceof Error ? error.message : String(error);
           logger.error(`[增量更新流程] ❌ 处理 ${title} 时出错:`, errMsg);
-          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+          await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
         }
       }
     }
@@ -596,7 +912,7 @@ async function incrementalUpdate(oldSite, newSite, config) {
 __name(incrementalUpdate, "incrementalUpdate");
 
 // src/sync/moduleSync.ts
-var import_koishi4 = require("koishi");
+var import_koishi7 = require("koishi");
 var CONFIG3 = {
   MODLE_NAMESPACE: 828,
   // 模块命名空间 (注意：这里原代码拼写为 MODLE，保留原样)
@@ -700,13 +1016,13 @@ async function syncModules(oldSite, newSite) {
       if (!syncResult.success) {
         failCount++;
         failedModules.push(moduleTitle);
-        await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
+        await (0, import_koishi7.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
       } else {
         successCount++;
         if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
           skipCount++;
         }
-        await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
+        await (0, import_koishi7.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
       }
     }
     if (failedModules.length > 0) {
@@ -731,11 +1047,11 @@ async function syncModules(oldSite, newSite) {
             skipCount++;
           }
           logger.info(`[SyncAllModules] ✅ 模块 ${moduleTitle} 重试成功`);
-          await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
+          await (0, import_koishi7.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
         } else {
           stillFailed.push(moduleTitle);
           logger.info(`[SyncAllModules] ❌ 模块 ${moduleTitle} 再次失败`);
-          await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
+          await (0, import_koishi7.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
         }
       }
       logger.info(`
@@ -755,303 +1071,366 @@ async function syncModules(oldSite, newSite) {
     logger.info(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
     logger.info(`└─ 失败：${failCount} 个`);
   } catch (error) {
-    logger.error(`[SyncAllModules] 💥 批量同步流程异常终止:`, error);
+    const errorMsg = getErrorMessage(error);
+    logger.error(`[SyncAllModules] 💥 批量同步流程异常终止:`, errorMsg);
     throw error;
   }
 }
 __name(syncModules, "syncModules");
 
-// src/index.ts
-var name = "oni-sync-bot";
-var inject = ["console", "database", "server", "cron"];
-var logBuffer = [];
-var Config = import_koishi5.Schema.object({
-  ggUsername: import_koishi5.Schema.string().description("WIKIGG 用户名").default("1"),
-  ggPassword: import_koishi5.Schema.string().description("WIKIGG 密码").default("1"),
-  bwikiusername: import_koishi5.Schema.string().description("bwiki用户名").default("1"),
-  bwikipassword: import_koishi5.Schema.string().description("bwiki密码").default("1"),
-  domain: import_koishi5.Schema.string().description("你的短链域名（必填，如：klei.vip）").default("klei.vip"),
-  main_site: import_koishi5.Schema.string().description("主站域名（必填，如：oxygennotincluded.wiki.gg）").default("oxygennotincluded.wiki.gg/zh"),
-  bwiki_site: import_koishi5.Schema.string().description("镜像站域名（必填，如：wiki.biligame.com）").default("wiki.biligame.com/oni"),
-  logsUrl: import_koishi5.Schema.string().description("日志查看地址").default("https://klei.vip/onilogs")
-});
-var PublicLogProvider = class extends import_plugin_console.DataService {
+// src/plugins/syncCommands.ts
+var SyncCommands = class {
   static {
-    __name(this, "PublicLogProvider");
-  }
-  constructor(ctx) {
-    super(ctx, "onilogs", { authority: 0 });
-  }
-  async get() {
-    return logBuffer;
+    __name(this, "SyncCommands");
   }
-};
-function apply(ctx, config) {
-  const log = ctx.logger("oni-sync");
-  let ggbot;
-  let bwikibot;
-  ctx.inject(["console"], (ctx2) => {
-    ctx2.console.addEntry({
-      dev: (0, import_path.resolve)(__dirname, "../client/index.ts"),
-      prod: (0, import_path.resolve)(__dirname, "../dist")
-    });
-  });
-  ctx.plugin(PublicLogProvider);
-  const target = {
-    colors: 0,
-    record: /* @__PURE__ */ __name((record) => {
-      if (record.name !== "oni-sync") return;
-      logBuffer.push(record);
-      if (logBuffer.length > 100) {
-        logBuffer = logBuffer.slice(-100);
-      }
-      ctx.get("console")?.patch("onilogs", logBuffer);
-    }, "record")
-  };
-  import_koishi5.Logger.targets.push(target);
-  ctx.on("dispose", () => {
-    const index = import_koishi5.Logger.targets.indexOf(target);
-    if (index > -1) import_koishi5.Logger.targets.splice(index, 1);
-  });
-  ctx.model.extend("wikipages", {
-    id: "integer",
-    title: "string",
-    pinyin_full: "string",
-    // 全拼
-    pinyin_first: "string"
-    // 首字母
-  });
-  ctx.server.get("/gg/:id", async (router) => {
-    const pageId = Number(router.params.id);
-    if (isNaN(pageId)) return router.body = "❌ 无效的页面ID，必须为数字！";
-    const [page] = await ctx.database.get("wikipages", { id: pageId });
-    if (!page)
-      return router.body = `❌ 未找到ID为【${pageId}】的页面，请联系管理员更新缓存！`;
-    const targetUrl = `https://${config.main_site}/${encodeURIComponent(
-      page.title
-    )}?variant=zh`;
-    router.redirect(targetUrl);
-  });
-  ctx.server.get("/bw/:id", async (router) => {
-    const pageId = Number(router.params.id);
-    if (isNaN(pageId)) return router.body = "❌ 无效的页面ID，必须为数字！";
-    const [page] = await ctx.database.get("wikipages", { id: pageId });
-    if (!page)
-      return router.body = `❌ 未找到ID为【${pageId}】的页面，请联系管理员更新缓存！`;
-    const targetUrl = `https://${config.bwiki_site}/${encodeURIComponent(
-      page.title
-    )}`;
-    router.redirect(targetUrl);
-  });
-  ctx.on("ready", async () => {
-    logger.info("初始化中...");
-    const sitesConfig = getSitesConfig(config);
-    ggbot = await login(sitesConfig.gg);
-    bwikibot = await login(sitesConfig.bwiki);
-    if (ggbot.login && bwikibot.login) {
-      logger.info("登录成功，插件已准备就绪");
-    } else {
-      logger.error("登录失败，请检查配置");
-    }
+  static inject = ["wikiBot", "cron"];
+  config;
+  log;
+  constructor(ctx, config) {
+    this.config = config;
+    this.log = ctx.logger("oni-sync");
+    logger.info("WikiBot 服务已就绪，初始化定时任务和指令");
     ctx.cron("15 * * * *", async () => {
-      await incrementalUpdate(ggbot, bwikibot, config);
+      if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
+        logger.warn("增量更新跳过：Wiki 机器人未就绪");
+        return;
+      }
+      await incrementalUpdate(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        config
+      );
     });
     ctx.cron("30 8 * * 4", async () => {
-      await syncPages(ggbot, bwikibot).then(() => {
+      if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
+        logger.warn("同步所有页面跳过：Wiki 机器人未就绪");
+        return;
+      }
+      await syncPages(ctx.wikiBot.getGGBot(), ctx.wikiBot.getBWikiBot()).then(() => {
         logger.info("自动任务：尝试同步所有页面，从 WIKIGG 到 bwiki");
       }).catch((err) => {
         logger.error(`同步所有页面失败`);
-        log.error(`，错误信息：${err}`);
+        this.log.error(`，错误信息：${err}`);
       });
     });
     ctx.cron("30 8 * * 3", async () => {
-      await syncAllImages(ggbot, bwikibot, config).then(() => {
+      if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
+        logger.warn("同步所有图片跳过：Wiki 机器人未就绪");
+        return;
+      }
+      await syncAllImages(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        config
+      ).then(() => {
         logger.info("自动任务：尝试同步所有图片，从 WIKIGG 到 bwiki");
       }).catch((err) => {
         logger.error(`同步所有图片失败`);
-        log.error(`，错误信息：${err}`);
+        this.log.error(`，错误信息：${err}`);
       });
     });
-  });
-  ctx.command("sync <pageTitle:string>", "同步指定页面", { authority: 2 }).action(async ({ session }, pageTitle) => {
-    await syncSinglePage(ggbot, bwikibot, pageTitle, "sync-bot").then(() => {
-      session.send(
-        `✅ 已尝试同步页面：${pageTitle}，请前往控制台查看：${config.logsUrl}`
-      );
-    }).catch((err) => {
-      session.send(`❌ 同步页面失败：${pageTitle}`);
-      log.error(`，错误信息：${err}`);
+    this.registerCommands(ctx);
+  }
+  checkBotsReady(ctx) {
+    const ggReady = ctx.wikiBot.isGGBotReady();
+    const bwReady = ctx.wikiBot.isBWikiBotReady();
+    return ggReady && bwReady;
+  }
+  registerCommands(ctx) {
+    ctx.command("sync <pageTitle:string>", "同步指定页面", { authority: 2 }).action(async ({ session }, pageTitle) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
+      await syncSinglePage(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        pageTitle,
+        "sync-bot"
+      ).then(() => {
+        session.send(
+          `✅ 已尝试同步页面：${pageTitle}，请前往控制台查看：${this.config.logsUrl}`
+        );
+      }).catch((err) => {
+        session.send(`❌ 同步页面失败：${pageTitle}`);
+        this.log.error(`，错误信息：${err}`);
+      });
     });
-  });
-  ctx.command("sync.incrementalUpdate", "获取3h内的编辑并尝试更新", {
-    authority: 2
-  }).alias("增量更新").action(async ({ session }) => {
-    session.send(
-      `🚀 获取3h内的编辑并尝试更新，任务耗时可能较长，请前往控制台查看日志:${config.logsUrl}`
-    );
-    await incrementalUpdate(ggbot, bwikibot, config).then(() => {
-      session.send(
-        `✅ 已尝试获取三小时前的编辑并同步，请前往控制台查看：${config.logsUrl}`
-      );
-    }).catch((err) => {
+    ctx.command("sync.incrementalUpdate", "获取3h内的编辑并尝试更新", {
+      authority: 2
+    }).alias("增量更新").action(async ({ session }) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
       session.send(
-        `❌ 同步所有页面失败，请前往控制台查看日志:${config.logsUrl}`
+        `🚀 获取3h内的编辑并尝试更新，任务耗时可能较长，请前往控制台查看日志:${this.config.logsUrl}`
       );
-      log.error(`同步所有页面失败，错误信息：${err}`);
+      await incrementalUpdate(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        this.config
+      ).then(() => {
+        session.send(
+          `✅ 已尝试获取三小时前的编辑并同步，请前往控制台查看：${this.config.logsUrl}`
+        );
+      }).catch((err) => {
+        session.send(
+          `❌ 同步所有页面失败，请前往控制台查看日志:${this.config.logsUrl}`
+        );
+        this.log.error(`同步所有页面失败，错误信息：${err}`);
+      });
     });
-  });
-  ctx.command("sync.allpages", "同步所有页面", { authority: 2 }).action(async ({ session }) => {
-    session.send(
-      `🚀 开始同步所有页面，任务耗时较长，请前往控制台查看日志:${config.logsUrl}`
-    );
-    await syncPages(ggbot, bwikibot).then(() => {
-      session.send(
-        `✅ 已尝试同步所有页面，请前往控制台查看：${config.logsUrl}`
-      );
-    }).catch((err) => {
+    ctx.command("sync.allpages", "同步所有页面", { authority: 2 }).action(async ({ session }) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
       session.send(
-        `❌ 同步所有页面失败，请前往控制台查看日志:${config.logsUrl}`
+        `🚀 开始同步所有页面，任务耗时较长，请前往控制台查看日志:${this.config.logsUrl}`
       );
-      log.error(`同步所有页面失败，错误信息：${err}`);
+      await syncPages(ctx.wikiBot.getGGBot(), ctx.wikiBot.getBWikiBot()).then(() => {
+        session.send(
+          `✅ 已尝试同步所有页面，请前往控制台查看：${this.config.logsUrl}`
+        );
+      }).catch((err) => {
+        session.send(
+          `❌ 同步所有页面失败，请前往控制台查看日志:${this.config.logsUrl}`
+        );
+        this.log.error(`同步所有页面失败，错误信息：${err}`);
+      });
     });
-  });
-  ctx.command("sync.module <moduleTitle:string>", "同步指定模块", {
-    authority: 2
-  }).action(async ({ session }, moduleTitle) => {
-    await session.send(`✅ 同步中，请前往控制台查看：${config.logsUrl}`);
-    await syncSingleModule(ggbot, bwikibot, moduleTitle, "sync-bot").then(() => {
-      session.send(
-        `✅ 已尝试同步模块：${moduleTitle}，请前往控制台查看：${config.logsUrl}`
+    ctx.command("sync.module <moduleTitle:string>", "同步指定模块", {
+      authority: 2
+    }).action(async ({ session }, moduleTitle) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
+      await session.send(
+        `✅ 同步中，请前往控制台查看：${this.config.logsUrl}`
       );
-    }).catch((err) => {
-      session.send(`❌ 同步模块失败：${moduleTitle}`);
-      log.error(`错误信息：${err}`);
+      await syncSingleModule(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        moduleTitle,
+        "sync-bot"
+      ).then(() => {
+        session.send(
+          `✅ 已尝试同步模块：${moduleTitle}，请前往控制台查看：${this.config.logsUrl}`
+        );
+      }).catch((err) => {
+        session.send(`❌ 同步模块失败：${moduleTitle}`);
+        this.log.error(`错误信息：${err}`);
+      });
     });
-  });
-  ctx.command("sync.allmodules", "同步所有模块", { authority: 2 }).action(async ({ session }) => {
-    await session.send(
-      `🚀 开始同步所有模块，任务耗时较长，请前往控制台查看：${config.logsUrl}`
-    );
-    await syncModules(ggbot, bwikibot).then(() => {
-      session.send(
-        `✅ 已尝试同步所有模块，请前往控制台查看：${config.logsUrl}`
-      );
-    }).catch((err) => {
-      session.send(
-        `❌ 同步所有模块失败，请前往控制台查看日志:${config.logsUrl}`
+    ctx.command("sync.allmodules", "同步所有模块", { authority: 2 }).action(async ({ session }) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
+      await session.send(
+        `🚀 开始同步所有模块，任务耗时较长，请前往控制台查看：${this.config.logsUrl}`
       );
-      log.error(`同步所有模块失败，错误信息：${err}`);
-    });
-  });
-  ctx.command("sync.img <imgTitle:string>", "同步指定图片", { authority: 2 }).action(async ({ session }, imgTitle) => {
-    await session.send(
-      `🚀 开始同步，任务可能耗时较长，请前往控制台查看：${config.logsUrl}`
-    );
-    await syncSingleImage(
-      ggbot,
-      bwikibot,
-      `${imgTitle.startsWith("File:") ? "" : "File:"}${imgTitle}`,
-      config
-    ).then(() => {
-      session.send(`✅ 已尝试同步图片：${imgTitle}`);
-    }).catch((err) => {
-      session.send(`❌ 同步图片失败：${imgTitle}`);
-      log.error(`同步图片失败：${imgTitle}，错误信息：${err}`);
+      await syncModules(ctx.wikiBot.getGGBot(), ctx.wikiBot.getBWikiBot()).then(() => {
+        session.send(
+          `✅ 已尝试同步所有模块，请前往控制台查看：${this.config.logsUrl}`
+        );
+      }).catch((err) => {
+        session.send(
+          `❌ 同步所有模块失败，请前往控制台查看日志:${this.config.logsUrl}`
+        );
+        this.log.error(`同步所有模块失败，错误信息：${err}`);
+      });
     });
-  });
-  ctx.command("sync.allimgs", "同步所有图片", { authority: 2 }).action(async ({ session }) => {
-    session.send(
-      `🚀 开始同步所有图片，任务耗时较长，请前往控制台查看：${config.logsUrl}`
-    );
-    await syncAllImages(ggbot, bwikibot, config).then(() => {
-      session.send(
-        `✅ 已尝试同步所有图片，请前往控制台查看：${config.logsUrl}`
+    ctx.command("sync.img <imgTitle:string>", "同步指定图片", { authority: 2 }).action(async ({ session }, imgTitle) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
+      await session.send(
+        `🚀 开始同步，任务可能耗时较长，请前往控制台查看：${this.config.logsUrl}`
       );
-    }).catch((err) => {
+      await syncSingleImage(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        `${imgTitle.startsWith("File:") ? "" : "File:"}${imgTitle}`,
+        this.config
+      ).then(() => {
+        session.send(`✅ 已尝试同步图片：${imgTitle}`);
+      }).catch((err) => {
+        session.send(`❌ 同步图片失败：${imgTitle}`);
+        this.log.error(`同步图片失败：${imgTitle}，错误信息：${err}`);
+      });
+    });
+    ctx.command("sync.allimgs", "同步所有图片", { authority: 2 }).action(async ({ session }) => {
+      if (!this.checkBotsReady(ctx)) {
+        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      }
       session.send(
-        `❌ 同步所有图片失败，请前往控制台查看日志:${config.logsUrl}`
+        `🚀 开始同步所有图片，任务耗时较长，请前往控制台查看：${this.config.logsUrl}`
       );
-      log.error(`同步所有图片失败，错误信息：${err}`);
+      await syncAllImages(
+        ctx.wikiBot.getGGBot(),
+        ctx.wikiBot.getBWikiBot(),
+        this.config
+      ).then(() => {
+        session.send(
+          `✅ 已尝试同步所有图片，请前往控制台查看：${this.config.logsUrl}`
+        );
+      }).catch((err) => {
+        session.send(
+          `❌ 同步所有图片失败，请前往控制台查看日志:${this.config.logsUrl}`
+        );
+        this.log.error(`同步所有图片失败，错误信息：${err}`);
+      });
     });
+  }
+};
+((SyncCommands2) => {
+  SyncCommands2.Config = import_koishi8.Schema.object({
+    ggUsername: import_koishi8.Schema.string().description("WIKIGG 用户名").default("1"),
+    ggPassword: import_koishi8.Schema.string().description("WIKIGG 密码").default("1"),
+    bwikiusername: import_koishi8.Schema.string().description("bwiki用户名").default("1"),
+    bwikipassword: import_koishi8.Schema.string().description("bwiki密码").default("1"),
+    domain: import_koishi8.Schema.string().description("你的短链域名（必填，如：klei.vip）").default("klei.vip"),
+    main_site: import_koishi8.Schema.string().description("主站域名（必填，如：oxygennotincluded.wiki.gg）").default("oxygennotincluded.wiki.gg/zh"),
+    bwiki_site: import_koishi8.Schema.string().description("镜像站域名（必填，如：wiki.biligame.com）").default("wiki.biligame.com/oni"),
+    logsUrl: import_koishi8.Schema.string().description("日志查看地址").default("https://klei.vip/onilogs")
   });
-  ctx.command("x <itemName>", "查询缺氧中文wiki，精准匹配+拼音模糊匹配").alias("/查wiki").action(async ({ session }, itemName = "") => {
-    const queryKey = itemName.trim().toLowerCase();
-    if (queryKey === "")
-      return `以下是使用说明：
-原站点: https://${config.domain}/gg/88888888
+})(SyncCommands || (SyncCommands = {}));
 
-bwiki: https://${config.domain}/bw/88888888`;
-    if (queryKey === "火箭计算器") {
-      return "请前往以下站点使用火箭计算器工具：\n\nhttps://klei.vip/calculator\n\n（注：该工具正在测试阶段，数据可能不够准确，仅供参考）";
-    }
-    const { pinyin_full: queryPinyinFull, pinyin_first: queryPinyinFirst } = generatePinyinInfo(queryKey);
-    const preciseTitleRes = await ctx.database.get("wikipages", {
-      title: queryKey
-    });
-    if (preciseTitleRes.length > 0) {
-      const { id: id2 } = preciseTitleRes[0];
-      return `✅ 精准匹配成功
-原站点: https://${config.domain}/gg/${id2}
-
-bwiki: https://${config.domain}/bw/${id2}`;
-    }
-    const preciseFullPinyinRes = await ctx.database.get("wikipages", {
-      pinyin_full: queryKey
+// src/plugins/queryCommands.ts
+var import_koishi9 = require("koishi");
+var SPECIAL_CASES = /* @__PURE__ */ new Map([
+  [
+    "火箭计算器",
+    "请前往以下站点使用火箭计算器工具：\n\nhttps://klei.vip/calculator\n\n（注：该工具正在测试阶段，数据可能不够准确，仅供参考）"
+  ]
+]);
+var QueryCommands = class {
+  static {
+    __name(this, "QueryCommands");
+  }
+  static inject = ["database"];
+  config;
+  constructor(ctx, config) {
+    this.config = config;
+    this.registerCommands(ctx);
+  }
+  registerCommands(ctx) {
+    ctx.command("x <itemName>", "查询缺氧中文wiki，精准匹配+拼音模糊匹配").alias("/查wiki").action(async ({ session }, itemName = "") => {
+      const queryKey = itemName.trim().toLowerCase();
+      if (!queryKey) {
+        return this.getUsageMessage();
+      }
+      if (SPECIAL_CASES.has(queryKey)) {
+        return SPECIAL_CASES.get(queryKey);
+      }
+      const { pinyin_full: queryPinyinFull, pinyin_first: queryPinyinFirst } = generatePinyinInfo(queryKey);
+      const preciseMatch = await this.findPreciseMatch(
+        ctx,
+        queryKey,
+        queryPinyinFull,
+        queryPinyinFirst
+      );
+      if (preciseMatch) {
+        return this.formatResultMessage(
+          preciseMatch,
+          preciseMatch.prefix
+        );
+      }
+      const allPages = await ctx.database.get("wikipages", {});
+      if (allPages.length === 0) {
+        return `❌ 本地缓存为空，请联系管理员执行【update】指令更新缓存！`;
+      }
+      const fuzzyMatches = this.findFuzzyMatches(
+        allPages,
+        queryKey,
+        queryPinyinFull,
+        queryPinyinFirst
+      );
+      if (fuzzyMatches.length === 0) {
+        return `❌ 未找到【${queryKey}】相关内容，请按游戏内标准名称重新查询！`;
+      }
+      return await this.handleSelection(session, fuzzyMatches);
     });
-    if (preciseFullPinyinRes.length > 0) {
-      const { id: id2, title } = preciseFullPinyinRes[0];
-      return `✅ 拼音精准匹配成功（${queryKey} → ${title}）
-原站点: https://${config.domain}/gg/${id2}
+  }
+  getUsageMessage() {
+    return `以下是使用说明：
+原站点: https://${this.config.domain}/gg/88888888
 
-bwiki: https://${config.domain}/bw/${id2}`;
+bwiki: https://${this.config.domain}/bw/88888888`;
+  }
+  formatResultMessage(match, prefix) {
+    let message = "";
+    if (prefix) {
+      message += prefix + "\n";
     }
-    const preciseFirstPinyinRes = await ctx.database.get("wikipages", {
-      pinyin_first: queryKey
-    });
-    if (preciseFirstPinyinRes.length > 0) {
-      const { id: id2, title } = preciseFirstPinyinRes[0];
-      return `✅ 首字母精准匹配成功（${queryKey} → ${title}）
-原站点: https://${config.domain}/gg/${id2}
+    message += `原站点: https://${this.config.domain}/gg/${match.id}
 
-bwiki: https://${config.domain}/bw/${id2} `;
+bwiki: https://${this.config.domain}/bw/${match.id}`;
+    return message;
+  }
+  async findPreciseMatch(ctx, queryKey, queryPinyinFull, queryPinyinFirst) {
+    const checks = [
+      { query: { title: queryKey }, prefix: "✅ 精准匹配成功" },
+      {
+        query: { pinyin_full: queryKey },
+        prefix: `✅ 拼音精准匹配成功（${queryKey} → `
+      },
+      {
+        query: { pinyin_first: queryKey },
+        prefix: `✅ 首字母精准匹配成功（${queryKey} → `
+      }
+    ];
+    for (const check of checks) {
+      const results = await ctx.database.get("wikipages", check.query);
+      if (results.length > 0) {
+        const match = results[0];
+        let prefix = check.prefix;
+        if (prefix && prefix.includes("→")) {
+          prefix += `${match.title}）`;
+        }
+        match.prefix = prefix;
+        return match;
+      }
     }
-    const allPages = await ctx.database.get("wikipages", {});
-    if (allPages.length === 0) {
-      return `❌ 本地缓存为空，请联系管理员执行【update】指令更新缓存！`;
+    return null;
+  }
+  calculateScore(page, queryKey, queryPinyinFull, queryPinyinFirst) {
+    let score = 0;
+    const { title, pinyin_full, pinyin_first } = page;
+    if (title.includes(queryKey)) score += 10;
+    if (pinyin_full.startsWith(queryPinyinFull)) score += 9;
+    if (pinyin_full.includes(queryPinyinFull)) score += 8;
+    if (pinyin_first.includes(queryPinyinFirst)) score += 6;
+    if (queryPinyinFull.includes(
+      pinyin_full.substring(
+        0,
+        Math.min(pinyin_full.length, queryPinyinFull.length)
+      )
+    )) {
+      score += 5;
     }
-    const matchResult = [];
-    allPages.forEach((page) => {
-      const { title, pinyin_full, pinyin_first } = page;
-      let score = 0;
-      if (title.includes(queryKey)) score += 10;
-      if (pinyin_full.startsWith(queryPinyinFull)) score += 9;
-      if (pinyin_full.includes(queryPinyinFull)) score += 8;
-      if (pinyin_first.includes(queryPinyinFirst)) score += 6;
-      if (queryPinyinFull.includes(
-        pinyin_full.substring(
-          0,
-          Math.min(pinyin_full.length, queryPinyinFull.length)
-        )
-      ))
-        score += 5;
+    return score;
+  }
+  findFuzzyMatches(allPages, queryKey, queryPinyinFull, queryPinyinFirst) {
+    const matchResults = [];
+    for (const page of allPages) {
+      const score = this.calculateScore(
+        page,
+        queryKey,
+        queryPinyinFull,
+        queryPinyinFirst
+      );
       if (score > 0) {
-        matchResult.push({ id: page.id, title, score });
+        matchResults.push({ id: page.id, title: page.title, score });
       }
-    });
-    if (matchResult.length === 0) {
-      return `❌ 未找到【${queryKey}】相关内容，请按游戏内标准名称重新查询！`;
     }
-    const sortedResult = matchResult.sort((a, b) => {
-      if (b.score !== a.score) return b.score - a.score;
-      return a.title.length - b.title.length;
-    });
-    const uniqueResult = Array.from(
-      new Map(sortedResult.map((item) => [item.title, item])).values()
+    return matchResults.sort((a, b) => b.score - a.score || a.title.length - b.title.length).filter(
+      (item, index, array) => array.findIndex((t) => t.title === item.title) === index
     ).slice(0, 5);
-    const resultCount = uniqueResult.length;
+  }
+  async handleSelection(session, matches) {
+    const resultCount = matches.length;
     let replyMsg = `🔍 未找到精准匹配，为你找到【 ${resultCount} 】个相似结果，请输入序号选择（10秒内有效）：
 `;
-    uniqueResult.forEach((item, index) => {
+    matches.forEach((item, index) => {
       replyMsg += `${index + 1}. ${item.title}
 `;
     });
@@ -1060,92 +1439,163 @@ bwiki: https://${config.domain}/bw/${id2} `;
     await session.send(replyMsg);
     const userInput = await session.prompt(15e3);
     if (!userInput) return;
-    const selectNum = parseInt(userInput.trim());
+    const selectNum = parseInt(userInput.trim(), 10);
     if (isNaN(selectNum) || selectNum < 1 || selectNum > resultCount) {
       return `❌ 输入无效！请输入 1-${resultCount} 之间的数字序号`;
     }
-    const { id } = uniqueResult[selectNum - 1];
-    return `✅ 选择成功
-原站点: https://${config.domain}/gg/${id}
-
-bwiki: https://${config.domain}/bw/${id}`;
+    const selected = matches[selectNum - 1];
+    return this.formatResultMessage(
+      selected,
+      "✅ 选择成功"
+    );
+  }
+};
+((QueryCommands2) => {
+  QueryCommands2.Config = import_koishi9.Schema.object({
+    domain: import_koishi9.Schema.string().description("你的短链域名（必填，如：klei.vip）").default("klei.vip")
   });
-  ctx.command("update", "更新本地页面缓存（主站）", { authority: 2 }).action(async ({ session }) => {
-    await session.execute("update.status");
-    try {
-      const res = await ggbot.request({
-        action: "query",
-        list: "allpages",
-        format: "json",
-        aplimit: "max"
-      });
-      logger.info("主站页面查询成功");
-      const pages = res.query.allpages || [];
-      const pageData = pages.map((page) => {
-        const { pinyin_full, pinyin_first } = generatePinyinInfo(page.title);
-        return {
-          id: page.pageid,
-          title: page.title,
-          pinyin_full,
-          pinyin_first
-        };
-      });
-      if (pageData.length > 0) {
-        await ctx.database.upsert("wikipages", pageData);
+})(QueryCommands || (QueryCommands = {}));
+
+// src/plugins/updateCommands.ts
+var import_koishi10 = require("koishi");
+var UpdateCommands = class {
+  static {
+    __name(this, "UpdateCommands");
+  }
+  static inject = ["database", "wikiBot"];
+  config;
+  log;
+  constructor(ctx, config) {
+    this.config = config;
+    this.log = ctx.logger("oni-sync");
+    this.registerCommands(ctx);
+  }
+  registerCommands(ctx) {
+    ctx.command("update", "更新本地页面缓存（主站）", { authority: 2 }).action(async ({ session }) => {
+      await session.execute("update.status");
+      try {
+        const res = await ctx.wikiBot.getGGBot().request({
+          action: "query",
+          list: "allpages",
+          format: "json",
+          aplimit: "max"
+        });
+        logger.info("主站页面查询成功");
+        const pages = res.query.allpages || [];
+        const pageData = pages.map((page) => {
+          const { pinyin_full, pinyin_first } = generatePinyinInfo(
+            page.title
+          );
+          return {
+            id: page.pageid,
+            title: page.title,
+            pinyin_full,
+            pinyin_first
+          };
+        });
+        if (pageData.length > 0) {
+          await ctx.database.upsert("wikipages", pageData);
+        }
+        session.send(`✅ 检索到 ${pages.length} 个页面，已更新至数据库`);
+        logger.info(`检索到 ${pages.length} 个页面，已更新至数据库`);
+      } catch (err) {
+        this.log.error("主站缓存更新失败", err);
+        session.send("❌ 主站缓存更新失败，请联系管理员查看日志");
       }
-      session.send(`✅ 检索到 ${pages.length} 个页面，已更新至数据库`);
-      logger.info(`检索到 ${pages.length} 个页面，已更新至数据库`);
-    } catch (err) {
-      log.error("主站缓存更新失败", err);
-      session.send("❌ 主站缓存更新失败，请联系管理员查看日志");
-    }
-  });
-  ctx.command("update.delete", "删除本地页面缓存", { authority: 4 }).action(async ({ session }) => {
-    try {
-      const count = await ctx.database.remove("wikipages", {});
-      session.send(`✅ 已删除 ${count.removed} 条本地缓存`);
-      logger.info(`已删除 ${count.removed} 条本地缓存`);
-    } catch (err) {
-      log.error("删除缓存失败", err);
-      session.send("❌ 删除缓存失败，请联系管理员查看日志");
-    }
-  });
-  ctx.command("update.status", "查询本地缓存数量", { authority: 1 }).action(async ({ session }) => {
-    try {
-      const pages = await ctx.database.get("wikipages", {});
-      session.send(`📊 数据库中缓存了 ${pages.length} 条页面`);
-      logger.info(`数据库中缓存了 ${pages.length} 条页面`);
-    } catch (err) {
-      log.error("查询缓存状态失败", err);
-      session.send("❌ 查询缓存状态失败，请联系管理员查看日志");
-    }
-  });
-  ctx.command("redirect <pageName> <targetPageName>", "添加原站点重定向", {
-    authority: 2
-  }).alias("重定向").action(async ({ session }, pageName, targetPageName) => {
-    if (!pageName || !targetPageName) {
-      return "❌ 参数错误！用法：redirect <原页面名> <目标页面名>";
-    }
-    try {
-      await ggbot.create(
-        pageName,
-        `#REDIRECT [[${targetPageName}]]`,
-        "来自qq机器人的添加重定向页面请求"
-      );
-      logger.info(`已为 ${pageName} 添加重定向至 ${targetPageName}`);
-      session.send(`✅ 已尝试添加重定向 ${pageName} -> ${targetPageName}`);
-      await session.execute(`update`);
-    } catch (err) {
-      log.error(`添加重定向 ${pageName} -> ${targetPageName} 失败`, err);
-      session.send(`❌ 添加重定向失败，请联系管理员查看日志`);
-    }
+    });
+    ctx.command("update.delete", "删除本地页面缓存", { authority: 4 }).action(async ({ session }) => {
+      try {
+        const count = await ctx.database.remove("wikipages", {});
+        session.send(`✅ 已删除 ${count.removed} 条本地缓存`);
+        logger.info(`已删除 ${count.removed} 条本地缓存`);
+      } catch (err) {
+        this.log.error("删除缓存失败", err);
+        session.send("❌ 删除缓存失败，请联系管理员查看日志");
+      }
+    });
+    ctx.command("update.status", "查询本地缓存数量", { authority: 1 }).action(async ({ session }) => {
+      try {
+        const pages = await ctx.database.get("wikipages", {});
+        session.send(`📊 数据库中缓存了 ${pages.length} 条页面`);
+        logger.info(`数据库中缓存了 ${pages.length} 条页面`);
+      } catch (err) {
+        this.log.error("查询缓存状态失败", err);
+        session.send("❌ 查询缓存状态失败，请联系管理员查看日志");
+      }
+    });
+    ctx.command("redirect <pageName> <targetPageName>", "添加原站点重定向", {
+      authority: 2
+    }).alias("重定向").action(async ({ session }, pageName, targetPageName) => {
+      if (!pageName || !targetPageName) {
+        return "❌ 参数错误！用法：redirect <原页面名> <目标页面名>";
+      }
+      try {
+        await ctx.wikiBot.getGGBot().create(
+          pageName,
+          `#REDIRECT [[${targetPageName}]]`,
+          "来自qq机器人的添加重定向页面请求"
+        );
+        logger.info(`已为 ${pageName} 添加重定向至 ${targetPageName}`);
+        session.send(`✅ 已尝试添加重定向 ${pageName} -> ${targetPageName}`);
+        await session.execute(`update`);
+      } catch (err) {
+        this.log.error(
+          `添加重定向 ${pageName} -> ${targetPageName} 失败`,
+          err
+        );
+        session.send(`❌ 添加重定向失败，请联系管理员查看日志`);
+      }
+    });
+    ctx.command("relogin", "手动重新登录 Wiki 机器人", { authority: 2 }).alias("重新登录").action(async ({ session }) => {
+      session.send("🚀 开始重新登录 Wiki 机器人...");
+      try {
+        const result = await ctx.wikiBot.relogin();
+        let message = "📋 重新登录结果：\n";
+        message += result.gg ? "✅ WIKIGG 登录成功\n" : "❌ WIKIGG 登录失败\n";
+        message += result.bwiki ? "✅ bwiki 登录成功\n" : "❌ bwiki 登录失败\n";
+        if (result.gg && result.bwiki) {
+          message += "\n🎉 两个 Wiki 机器人都已成功登录！";
+        } else if (result.gg || result.bwiki) {
+          message += "\n⚠️  部分 Wiki 机器人已登录";
+        } else {
+          message += "\n💥 所有 Wiki 机器人登录都失败了，请检查配置";
+        }
+        session.send(message);
+      } catch (err) {
+        this.log.error("重新登录失败", err);
+        session.send("❌ 重新登录过程中发生错误，请查看日志");
+      }
+    });
+  }
+};
+((UpdateCommands2) => {
+  UpdateCommands2.Config = import_koishi10.Schema.object({
+    logsUrl: import_koishi10.Schema.string().description("日志查看地址").default("https://klei.vip/onilogs")
   });
+})(UpdateCommands || (UpdateCommands = {}));
+
+// src/index.ts
+var name = "oni-sync-bot";
+var Config = import_koishi11.Schema.intersect([
+  WikiBotService.Config,
+  RouteRedirect.Config,
+  SyncCommands.Config,
+  QueryCommands.Config,
+  UpdateCommands.Config
+]);
+function apply(ctx, config) {
+  ctx.plugin(WikiBotService, config);
+  ctx.plugin(ConsoleLogProvider);
+  ctx.plugin(DatabaseExtension);
+  ctx.plugin(RouteRedirect, config);
+  ctx.plugin(SyncCommands, config);
+  ctx.plugin(QueryCommands, config);
+  ctx.plugin(UpdateCommands, config);
 }
 __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Config,
   apply,
-  inject,
   name
 });