koishi-plugin-oni-sync-bot 0.8.2 → 0.8.5

package/lib/index.js

@@ -62,7 +62,10 @@ async function getAndProcessPageContent(site, pageTitle) {
   try {
     let rawText = "";
     try {
-      const res = await site.read(pageTitle);
+      const res = await site.read(pageTitle, {
+        redirects: false
+        // 不自动跟随重定向
+      });
       if (res) {
         if (typeof res === "string") {
           rawText = res;
@@ -445,7 +448,7 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
   });
 })(WikiBotService || (WikiBotService = {}));
 
-// src/plugins/consoleLogProvider.ts
+// src/services/consoleLogProvider.ts
 var import_koishi3 = require("koishi");
 var import_plugin_console = require("@koishijs/plugin-console");
 var logBuffer = [];
@@ -815,7 +818,7 @@ __name(syncAllImages, "syncAllImages");
 
 // src/sync/pageSync.ts
 var CONFIG2 = {
-  IGNORED_PAGES: /* @__PURE__ */ new Set(["教程", "MediaWiki:Common.css"]),
+  IGNORED_PAGES: /* @__PURE__ */ new Set(["教程", "MediaWiki:Common.css", "首页", "Main Page"]),
   SYNC_INTERVAL_SUCCESS: 500,
   SYNC_INTERVAL_FAILED: 1e3,
   NAMESPACE: 0,
@@ -1051,8 +1054,8 @@ __name(incrementalUpdate, "incrementalUpdate");
 // src/sync/moduleSync.ts
 var import_koishi7 = require("koishi");
 var CONFIG3 = {
-  MODLE_NAMESPACE: 828,
-  // 模块命名空间 (注意：这里原代码拼写为 MODLE，保留原样)
+  MODULE_NAMESPACE: 828,
+  // 模块命名空间
   IGNORED_MODULES: [],
   // 忽略的模块列表
   SYNC_INTERVAL_SUCCESS: 500,
@@ -1099,13 +1102,13 @@ async function syncSingleModule(oldSite, newSite, moduleTitle, user) {
 __name(syncSingleModule, "syncSingleModule");
 async function getAllModules(site) {
   logger.info(
-    `[SyncAllModules] 📥 开始获取原站点所有模块（命名空间${CONFIG3.MODLE_NAMESPACE}）`
+    `[SyncAllModules] 📥 开始获取原站点所有模块（命名空间${CONFIG3.MODULE_NAMESPACE}）`
   );
   const allModules = [];
   const queryGen = site.continuedQueryGen({
     action: "query",
     list: "allpages",
-    apnamespace: CONFIG3.MODLE_NAMESPACE,
+    apnamespace: CONFIG3.MODULE_NAMESPACE,
     // 模块命名空间
     aplimit: "max",
     apdir: "ascending"
@@ -1125,7 +1128,6 @@ async function syncModules(oldSite, newSite) {
   try {
     const oldModuleList = await getAllModules(oldSite);
     const total = oldModuleList.length;
-    console.log(oldModuleList);
     if (total === 0) {
       logger.info(`[SyncAllModules] 📭 原站点无模块可同步，结束`);
       return;
@@ -1222,16 +1224,11 @@ var SyncCommands = class {
   }
   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 () => {
-      if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
-        logger.warn("增量更新跳过：Wiki 机器人未就绪");
-        return;
-      }
+      if (!await this.ensureBotsReady(ctx, "增量更新")) return;
       await incrementalUpdate(
         ctx.wikiBot.getGGBot(),
         ctx.wikiBot.getBWikiBot(),
@@ -1239,22 +1236,15 @@ var SyncCommands = class {
       );
     });
     ctx.cron("30 8 * * 4", async () => {
-      if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
-        logger.warn("同步所有页面跳过：Wiki 机器人未就绪");
-        return;
-      }
+      if (!await this.ensureBotsReady(ctx, "同步所有页面")) return;
       await syncPages(ctx.wikiBot.getGGBot(), ctx.wikiBot.getBWikiBot()).then(() => {
         logger.info("自动任务：尝试同步所有页面，从 WIKIGG 到 bwiki");
       }).catch((err) => {
-        logger.error(`同步所有页面失败`);
-        this.log.error(`，错误信息：${err}`);
+        logger.error(`同步所有页面失败，错误信息：${err}`);
       });
     });
     ctx.cron("30 8 * * 3", async () => {
-      if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
-        logger.warn("同步所有图片跳过：Wiki 机器人未就绪");
-        return;
-      }
+      if (!await this.ensureBotsReady(ctx, "同步所有图片")) return;
       await syncAllImages(
         ctx.wikiBot.getGGBot(),
         ctx.wikiBot.getBWikiBot(),
@@ -1262,159 +1252,148 @@ var SyncCommands = class {
       ).then(() => {
         logger.info("自动任务：尝试同步所有图片，从 WIKIGG 到 bwiki");
       }).catch((err) => {
-        logger.error(`同步所有图片失败`);
-        this.log.error(`，错误信息：${err}`);
+        logger.error(`同步所有图片失败，错误信息：${err}`);
       });
     });
     this.registerCommands(ctx);
   }
-  checkBotsReady(ctx) {
+  /**
+   * 确保机器人就绪，如果未就绪则尝试重新登录
+   * @param ctx Koishi 上下文
+   * @param taskName 任务名称（用于日志）
+   * @returns 机器人是否已就绪
+   */
+  async ensureBotsReady(ctx, taskName) {
+    if (!ctx.wikiBot.isGGBotReady() || !ctx.wikiBot.isBWikiBotReady()) {
+      logger.warn(`检测到部分机器人未就绪，尝试重新登录...`);
+      try {
+        await ctx.wikiBot.relogin();
+      } catch (error) {
+        logger.error(`重新登录失败: ${error}`);
+        return false;
+      }
+    }
     const ggReady = ctx.wikiBot.isGGBotReady();
-    const bwReady = ctx.wikiBot.isBWikiBotReady();
-    return ggReady && bwReady;
+    const bwikiReady = ctx.wikiBot.isBWikiBotReady();
+    if (!ggReady || !bwikiReady) {
+      logger.warn(
+        `${taskName} 跳过：Wiki 机器人仍未就绪 - WIKIGG: ${ggReady ? "✅" : "❌"}, bwiki: ${bwikiReady ? "✅" : "❌"}`
+      );
+      return false;
+    }
+    return true;
   }
   registerCommands(ctx) {
     ctx.command("sync <pageTitle:string>", "同步指定页面", { authority: 2 }).action(async ({ session }, pageTitle) => {
-      if (!this.checkBotsReady(ctx)) {
-        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "同步页面")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
       }
-      await syncSinglePage(
-        ctx.wikiBot.getGGBot(),
-        ctx.wikiBot.getBWikiBot(),
-        pageTitle,
-        "sync-bot"
-      ).then(() => {
-        session.send(
-          `✅ 已尝试同步页面：${pageTitle}，请前往控制台查看：${this.config.logsUrl}`
+      try {
+        await syncSinglePage(
+          ctx.wikiBot.getGGBot(),
+          ctx.wikiBot.getBWikiBot(),
+          pageTitle,
+          "sync-bot"
         );
-      }).catch((err) => {
-        session.send(`❌ 同步页面失败：${pageTitle}`);
-        this.log.error(`，错误信息：${err}`);
-      });
+        return `✅ 已尝试同步页面：${pageTitle}，请前往控制台查看：${this.config.logsUrl}`;
+      } catch (err) {
+        logger.error(`同步页面 ${pageTitle} 失败，错误信息：${err}`);
+        return `❌ 同步页面失败：${pageTitle}`;
+      }
     });
     ctx.command("sync.incrementalUpdate", "获取3h内的编辑并尝试更新", {
       authority: 2
     }).alias("增量更新").action(async ({ session }) => {
-      if (!this.checkBotsReady(ctx)) {
-        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "增量更新")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
       }
-      session.send(
-        `🚀 获取3h内的编辑并尝试更新，任务耗时可能较长，请前往控制台查看日志:${this.config.logsUrl}`
-      );
-      await incrementalUpdate(
-        ctx.wikiBot.getGGBot(),
-        ctx.wikiBot.getBWikiBot(),
-        this.config
-      ).then(() => {
-        session.send(
-          `✅ 已尝试获取三小时前的编辑并同步，请前往控制台查看：${this.config.logsUrl}`
-        );
-      }).catch((err) => {
-        session.send(
-          `❌ 同步所有页面失败，请前往控制台查看日志:${this.config.logsUrl}`
+      try {
+        await incrementalUpdate(
+          ctx.wikiBot.getGGBot(),
+          ctx.wikiBot.getBWikiBot(),
+          this.config
         );
-        this.log.error(`同步所有页面失败，错误信息：${err}`);
-      });
+        return `✅ 已尝试获取三小时前的编辑并同步，请前往控制台查看：${this.config.logsUrl}`;
+      } catch (err) {
+        logger.error(`增量更新失败，错误信息：${err}`);
+        return `❌ 增量更新失败，请前往控制台查看日志：${this.config.logsUrl}`;
+      }
     });
     ctx.command("sync.allpages", "同步所有页面", { authority: 2 }).action(async ({ session }) => {
-      if (!this.checkBotsReady(ctx)) {
-        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "同步所有页面")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
+      }
+      try {
+        await syncPages(ctx.wikiBot.getGGBot(), ctx.wikiBot.getBWikiBot());
+        return `✅ 已尝试同步所有页面，请前往控制台查看：${this.config.logsUrl}`;
+      } catch (err) {
+        logger.error(`同步所有页面失败，错误信息：${err}`);
+        return `❌ 同步所有页面失败，请前往控制台查看日志:${this.config.logsUrl}`;
       }
-      session.send(
-        `🚀 开始同步所有页面，任务耗时较长，请前往控制台查看日志:${this.config.logsUrl}`
-      );
-      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) => {
-      if (!this.checkBotsReady(ctx)) {
-        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "同步模块")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
       }
-      await session.send(
-        `✅ 同步中，请前往控制台查看：${this.config.logsUrl}`
-      );
-      await syncSingleModule(
-        ctx.wikiBot.getGGBot(),
-        ctx.wikiBot.getBWikiBot(),
-        moduleTitle,
-        "sync-bot"
-      ).then(() => {
-        session.send(
-          `✅ 已尝试同步模块：${moduleTitle}，请前往控制台查看：${this.config.logsUrl}`
+      try {
+        await syncSingleModule(
+          ctx.wikiBot.getGGBot(),
+          ctx.wikiBot.getBWikiBot(),
+          moduleTitle,
+          "sync-bot"
         );
-      }).catch((err) => {
-        session.send(`❌ 同步模块失败：${moduleTitle}`);
-        this.log.error(`错误信息：${err}`);
-      });
+        return `✅ 已尝试同步模块：${moduleTitle}，请前往控制台查看：${this.config.logsUrl}`;
+      } catch (err) {
+        logger.error(`同步模块 ${moduleTitle} 失败，错误信息：${err}`);
+        return `❌ 同步模块失败：${moduleTitle}`;
+      }
     });
     ctx.command("sync.allmodules", "同步所有模块", { authority: 2 }).action(async ({ session }) => {
-      if (!this.checkBotsReady(ctx)) {
-        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "同步所有模块")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
+      }
+      try {
+        await syncModules(ctx.wikiBot.getGGBot(), ctx.wikiBot.getBWikiBot());
+        return `✅ 已尝试同步所有模块，请前往控制台查看：${this.config.logsUrl}`;
+      } catch (err) {
+        logger.error(`同步所有模块失败，错误信息：${err}`);
+        return `❌ 同步所有模块失败，请前往控制台查看日志:${this.config.logsUrl}`;
       }
-      await session.send(
-        `🚀 开始同步所有模块，任务耗时较长，请前往控制台查看：${this.config.logsUrl}`
-      );
-      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.img <imgTitle:string>", "同步指定图片", { authority: 2 }).action(async ({ session }, imgTitle) => {
-      if (!this.checkBotsReady(ctx)) {
-        return session.send("❌ Wiki 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "同步图片")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
+      }
+      try {
+        await syncSingleImage(
+          ctx.wikiBot.getGGBot(),
+          ctx.wikiBot.getBWikiBot(),
+          `${imgTitle.startsWith("File:") ? "" : "File:"}${imgTitle}`,
+          this.config
+        );
+        return `✅ 已尝试同步图片：${imgTitle}`;
+      } catch (err) {
+        logger.error(`同步图片 ${imgTitle} 失败，错误信息：${err}`);
+        return `❌ 同步图片失败：${imgTitle}`;
       }
-      await session.send(
-        `🚀 开始同步，任务可能耗时较长，请前往控制台查看：${this.config.logsUrl}`
-      );
-      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 机器人未就绪，请检查登录配置或查看日志");
+      if (!await this.ensureBotsReady(ctx, "同步所有图片")) {
+        return "❌ Wiki 机器人未就绪，请检查登录配置或查看日志";
       }
-      session.send(
-        `🚀 开始同步所有图片，任务耗时较长，请前往控制台查看：${this.config.logsUrl}`
-      );
-      await syncAllImages(
-        ctx.wikiBot.getGGBot(),
-        ctx.wikiBot.getBWikiBot(),
-        this.config
-      ).then(() => {
-        session.send(
-          `✅ 已尝试同步所有图片，请前往控制台查看：${this.config.logsUrl}`
-        );
-      }).catch((err) => {
-        session.send(
-          `❌ 同步所有图片失败，请前往控制台查看日志:${this.config.logsUrl}`
+      try {
+        await syncAllImages(
+          ctx.wikiBot.getGGBot(),
+          ctx.wikiBot.getBWikiBot(),
+          this.config
         );
-        this.log.error(`同步所有图片失败，错误信息：${err}`);
-      });
+        return `✅ 已尝试同步所有图片，请前往控制台查看：${this.config.logsUrl}`;
+      } catch (err) {
+        logger.error(`同步所有图片失败，错误信息：${err}`);
+        return `❌ 同步所有图片失败，请前往控制台查看日志:${this.config.logsUrl}`;
+      }
     });
   }
 };

package/lib/plugins/syncCommands.d.ts

@@ -1,4 +1,4 @@
-import { Context, Logger, Schema } from "koishi";
+import { Context, Schema } from "koishi";
 export interface SyncCommandsConfig {
     logsUrl: string;
     ggUsername: string;
@@ -12,9 +12,14 @@ export interface SyncCommandsConfig {
 export declare class SyncCommands {
     static readonly inject: string[];
     config: SyncCommandsConfig;
-    log: Logger;
     constructor(ctx: Context, config: SyncCommandsConfig);
-    private checkBotsReady;
+    /**
+     * 确保机器人就绪，如果未就绪则尝试重新登录
+     * @param ctx Koishi 上下文
+     * @param taskName 任务名称（用于日志）
+     * @returns 机器人是否已就绪
+     */
+    private ensureBotsReady;
     private registerCommands;
 }
 export declare namespace SyncCommands {

package/lib/services/consoleLogProvider.d.ts

@@ -0,0 +1,13 @@
+import { Context, Logger } from "koishi";
+declare module "@koishijs/console" {
+    namespace Console {
+        interface Services {
+            onilogs: DataService<Logger.Record[]>;
+        }
+    }
+}
+export declare class ConsoleLogProvider {
+    static readonly inject: string[];
+    constructor(ctx: Context);
+}
+export declare function apply(ctx: Context): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-oni-sync-bot",
   "description": "缺氧Wiki站镜像点同步-测试",
-  "version": "0.8.2",
+  "version": "0.8.5",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [

package/readme.md

@@ -156,12 +156,12 @@ yarn add koishi-plugin-oni-sync-bot
 koishi-plugin-oni-sync-bot/
 ├── src/
 │   ├── services/         # 服务层
-│   │   └── wikiBotService.ts    # Wiki 机器人服务
+│   │   ├── wikiBotService.ts    # Wiki 机器人服务
+│   │   └── consoleLogProvider.ts # 日志控制台服务
 │   ├── plugins/          # 插件层
 │   │   ├── queryCommands.ts     # 查询命令插件
 │   │   ├── syncCommands.ts      # 同步命令插件
 │   │   ├── updateCommands.ts    # 更新命令插件
-│   │   ├── consoleLogProvider.ts # 日志控制台插件
 │   │   ├── todoList.ts          # TodoList 插件
 │   │   ├── databaseExtension.ts  # 数据库扩展
 │   │   └── routeRedirect.ts     # 路由重定向