koishi-plugin-oni-sync-bot 0.8.7 → 0.9.0

package/lib/index.js

@@ -186,30 +186,19 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
   }
   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
-      );
+      logger.error(`❌ ${siteConfig.name} 登录失败`, errorMsg);
       throw error;
     }
   }
   async login(siteConfig) {
-    logger.info(`正在连接 ${siteConfig.name} API: ${siteConfig.api}`);
     const bot = new import_mwn.Mwn({
       apiUrl: siteConfig.api,
       username: siteConfig.username,
@@ -225,9 +214,7 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
       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 注入成功");
+          logger.warn("bwiki Cookie 注入失败:", err);
         }
       });
       bot.setRequestOptions({
@@ -237,96 +224,63 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
         }
       });
     }
-    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);
+        logger.info("✅ WIKIGG 登录成功");
       } catch (error) {
-        const errorMsg = getErrorMessage(error);
-        logger.error(
-          "WIKIGG 登录失败，服务将继续运行，但 WIKIGG 相关功能不可用",
-          errorMsg
-        );
+        this.ggbot = null;
       }
-      logger.info("开始登录 bwiki...");
       try {
         this.bwikibot = await this.loginWithRetry(sitesConfig.bwiki);
+        logger.info("✅ bwiki 登录成功");
       } catch (error) {
-        const errorMsg = getErrorMessage(error);
-        logger.error(
-          "bwiki 登录失败，服务将继续运行，但 bwiki 相关功能不可用",
-          errorMsg
-        );
+        this.bwikibot = null;
       }
-      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 初始化失败，所有登录都失败");
+      this.isReady = this.ggbot !== null || this.bwikibot !== null;
+      if (!this.isReady) {
+        logger.error("❌ WikiBotService 初始化失败，两个 Wiki 均无法登录");
       }
     } catch (error) {
       const errorMsg = getErrorMessage(error);
-      logger.error("WikiBotService 初始化出错:", errorMsg);
+      logger.error("❌ WikiBotService 初始化异常:", errorMsg);
     }
   }
   stop() {
     this.isReady = false;
     this.ggbot = null;
     this.bwikibot = null;
-    logger.info("WikiBotService 已停止");
+    this.ggbotProxy = null;
+    this.bwikibotProxy = null;
   }
   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");
+      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");
+      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 重新登录失败，所有登录都失败");
     }
+    this.isReady = this.ggbot !== null || this.bwikibot !== null;
     return { gg: ggSuccess, bwiki: bwikiSuccess };
   }
   async reloginSite(site) {
+    const siteName = site === "gg" ? "WIKIGG" : "bwiki";
     const sitesConfig = this.getSitesConfig();
     const siteConfig = site === "gg" ? sitesConfig.gg : sitesConfig.bwiki;
     try {
@@ -336,15 +290,13 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
       } else {
         this.bwikibot = bot;
       }
-      logger.info(`✅ ${siteConfig.name} 自动重新登录成功`);
+      logger.info(`✅ ${siteName} 自动重新登录成功`);
     } catch (error) {
-      const errorMsg = getErrorMessage(error);
       if (site === "gg") {
         this.ggbot = null;
       } else {
         this.bwikibot = null;
       }
-      logger.error(`❌ ${siteConfig.name} 自动重新登录失败`, errorMsg);
       throw error;
     }
   }
@@ -354,71 +306,77 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
   isBWikiBotReady() {
     return this.bwikibot !== null;
   }
-  createBotProxy(bot, site) {
+  createBotProxy(site) {
     const self = this;
-    const METHODS_TO_SKIP = /* @__PURE__ */ new Set([
-      "cookieJar",
-      "setRequestOptions"
-    ]);
-    return new Proxy(bot, {
-      get(target, prop) {
-        const originalMethod = target[prop];
-        if (typeof originalMethod !== "function") {
-          return originalMethod;
+    const METHODS_TO_SKIP = /* @__PURE__ */ new Set(["cookieJar", "setRequestOptions"]);
+    const getCurrentBot = /* @__PURE__ */ __name(() => {
+      const bot = site === "gg" ? self.ggbot : self.bwikibot;
+      if (!bot) {
+        throw new Error(
+          `${site === "gg" ? "WIKIGG" : "bwiki"} bot 尚未就绪，请检查登录配置或查看日志`
+        );
+      }
+      return bot;
+    }, "getCurrentBot");
+    return new Proxy({}, {
+      get(_target, prop) {
+        const propKey = prop;
+        const currentBot = getCurrentBot();
+        const value = currentBot[propKey];
+        if (typeof value !== "function") {
+          return value;
         }
         if (METHODS_TO_SKIP.has(prop)) {
-          return originalMethod.bind(target);
+          return value.bind(currentBot);
         }
         if (prop === "continuedQueryGen") {
           return function(...args) {
-            const originalGen = originalMethod.apply(target, args);
+            let activeBot = getCurrentBot();
+            let activeMethod = activeBot.continuedQueryGen;
+            let activeIterator = activeMethod.apply(activeBot, args)[Symbol.asyncIterator]();
             return {
               [Symbol.asyncIterator]() {
-                const it = originalGen[Symbol.asyncIterator]();
-                return {
-                  async next() {
-                    try {
-                      return await it.next();
-                    } catch (error) {
-                      if (error.code === "assertuserfailed") {
-                        logger.warn(
-                          `检测到 ${site === "gg" ? "WIKIGG" : "bwiki"} 登录过期，正在自动重新登录...`
-                        );
-                        await self.reloginSite(site);
-                        const newBot = site === "gg" ? self.ggbot : self.bwikibot;
-                        if (!newBot) {
-                          throw new Error(
-                            `${site === "gg" ? "WIKIGG" : "bwiki"} 自动重新登录失败`
-                          );
-                        }
-                        const newGen = newBot.continuedQueryGen(...args);
-                        const newIt = newGen[Symbol.asyncIterator]();
-                        return await newIt.next();
-                      }
-                      throw error;
-                    }
+                return this;
+              },
+              async next() {
+                try {
+                  return await activeIterator.next();
+                } catch (error) {
+                  if (error.code === "assertuserfailed") {
+                    await self.reloginSite(site);
+                    activeBot = getCurrentBot();
+                    activeMethod = activeBot.continuedQueryGen;
+                    const newGen = activeMethod.apply(activeBot, args);
+                    activeIterator = newGen[Symbol.asyncIterator]();
+                    return await activeIterator.next();
                   }
-                };
+                  throw error;
+                }
               }
             };
           };
         }
         return async function(...args) {
+          let executeBot = getCurrentBot();
+          let method = executeBot[propKey];
+          if (typeof method !== "function") {
+            throw new Error(
+              `${site === "gg" ? "WIKIGG" : "bwiki"} bot 缺少方法 ${String(prop)}`
+            );
+          }
           try {
-            return await originalMethod.apply(target, args);
+            return await method.apply(executeBot, args);
           } catch (error) {
             if (error.code === "assertuserfailed") {
-              logger.warn(
-                `检测到 ${site === "gg" ? "WIKIGG" : "bwiki"} 登录过期，正在自动重新登录...`
-              );
               await self.reloginSite(site);
-              const newBot = site === "gg" ? self.ggbot : self.bwikibot;
-              if (!newBot) {
+              executeBot = getCurrentBot();
+              method = executeBot[propKey];
+              if (typeof method !== "function") {
                 throw new Error(
-                  `${site === "gg" ? "WIKIGG" : "bwiki"} 自动重新登录失败`
+                  `${site === "gg" ? "WIKIGG" : "bwiki"} 新 bot 缺少方法 ${String(prop)}`
                 );
               }
-              return await newBot[prop].apply(newBot, args);
+              return await method.apply(executeBot, args);
             }
             throw error;
           }
@@ -426,17 +384,25 @@ var WikiBotService = class _WikiBotService extends import_koishi2.Service {
       }
     });
   }
+  ggbotProxy = null;
+  bwikibotProxy = null;
   getGGBot() {
     if (!this.ggbot) {
       throw new Error("WIKIGG bot 尚未就绪，请检查登录配置或查看日志");
     }
-    return this.createBotProxy(this.ggbot, "gg");
+    if (!this.ggbotProxy) {
+      this.ggbotProxy = this.createBotProxy("gg");
+    }
+    return this.ggbotProxy;
   }
   getBWikiBot() {
     if (!this.bwikibot) {
       throw new Error("bwiki bot 尚未就绪，请检查登录配置或查看日志");
     }
-    return this.createBotProxy(this.bwikibot, "bwiki");
+    if (!this.bwikibotProxy) {
+      this.bwikibotProxy = this.createBotProxy("bwiki");
+    }
+    return this.bwikibotProxy;
   }
 };
 ((WikiBotService2) => {
@@ -537,6 +503,20 @@ var RouteRedirect = class {
       )}`;
       router.redirect(targetUrl);
     });
+    ctx.server.use("/ggwiki", async (router, next) => {
+      const fullPath = router.path.replace("/ggwiki", "") || "";
+      const decodedPath = decodeURIComponent(fullPath);
+      if (decodedPath.includes("..")) {
+        return router.body = "❌ 非法路径访问！";
+      }
+      if (!/^(\/[\p{L}\p{N}_\-:.%]+)*\/?$/u.test(fullPath)) {
+        return router.body = "❌ 路径包含非法字符！";
+      }
+      const queryString = router.querystring ? `?${router.querystring}` : "";
+      const targetUrl = `https://${this.config.main_site}${fullPath}${queryString}`;
+      router.redirect(targetUrl);
+      return;
+    });
   }
 };
 ((RouteRedirect2) => {
@@ -564,11 +544,21 @@ var CONFIG = {
   UPLOAD_COMMENT: "从 WikiGG 自动同步转存",
   UPLOAD_TEXT: "== 授权说明 ==\n本文件从 WikiGG 转存，遵循原站点授权协议。"
 };
+function normalizeImageTitle(fileName) {
+  const trimmed = fileName.trim();
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("file:") || lower.startsWith("image:") || lower.startsWith("文件:")) {
+    return trimmed;
+  }
+  return `File:${trimmed}`;
+}
+__name(normalizeImageTitle, "normalizeImageTitle");
 async function getImageInfo(site, fileName) {
   try {
+    const normalizedTitle = normalizeImageTitle(fileName);
     const response = await site.query({
       action: "query",
-      titles: fileName,
+      titles: normalizedTitle,
       prop: "imageinfo",
       iiprop: "url|sha1|size|mime"
     });
@@ -592,9 +582,10 @@ async function getImageInfo(site, fileName) {
 __name(getImageInfo, "getImageInfo");
 async function deleteOldVersions(bot, fileName) {
   try {
+    const normalizedTitle = normalizeImageTitle(fileName);
     const response = await bot.query({
       action: "query",
-      titles: fileName,
+      titles: normalizedTitle,
       prop: "revisions",
       rvprop: "ids|timestamp",
       rvlimit: "max",
@@ -634,19 +625,32 @@ async function deleteOldVersions(bot, fileName) {
   }
 }
 __name(deleteOldVersions, "deleteOldVersions");
+function stripImagePrefix(fileName) {
+  const trimmed = fileName.trim();
+  const lower = trimmed.toLowerCase();
+  const prefixes = ["file:", "image:", "文件:"];
+  for (const p of prefixes) {
+    if (lower.startsWith(p)) {
+      return trimmed.substring(p.length);
+    }
+  }
+  return trimmed;
+}
+__name(stripImagePrefix, "stripImagePrefix");
 async function syncSingleImage(sourceBot, targetBot, fileName, config) {
   if (CONFIG.IGNORED_IMAGES.includes(fileName)) {
     logger.info(`[SyncImg] 🚫 图片 ${fileName} 在忽略列表，跳过`);
     return { success: true, reason: "ignored" };
   }
+  const bareFileName = stripImagePrefix(fileName);
   try {
-    logger.info(`[SyncImg] 🚀 开始处理: ${fileName}`);
-    const sourceImageInfo = await getImageInfo(sourceBot, fileName);
+    logger.info(`[SyncImg] 🚀 开始处理: ${bareFileName}`);
+    const sourceImageInfo = await getImageInfo(sourceBot, bareFileName);
     if (!sourceImageInfo) {
       logger.info(`[SyncImg] ❌ 源站未找到图片: ${fileName}`);
       return { success: false, reason: "source_missing" };
     }
-    const targetImageInfo = await getImageInfo(targetBot, fileName);
+    const targetImageInfo = await getImageInfo(targetBot, bareFileName);
     logger.info(`原图片sha1: ${sourceImageInfo.sha1}`);
     logger.info(`目标图片sha1: ${targetImageInfo?.sha1}`);
     if (targetImageInfo && targetImageInfo.sha1 === sourceImageInfo.sha1) {
@@ -664,19 +668,19 @@ async function syncSingleImage(sourceBot, targetBot, fileName, config) {
     }
     const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
     logger.info(
-      `[SyncImg] 📤 上传图片: ${fileName} (大小: ${(imageBuffer.length / 1024).toFixed(1)} KB)`
+      `[SyncImg] 📤 上传图片: ${bareFileName} (大小: ${(imageBuffer.length / 1024).toFixed(1)} KB)`
     );
     const token = await targetBot.getCsrfToken();
     const form = new import_form_data.default();
     form.append("action", "upload");
-    form.append("filename", fileName);
+    form.append("filename", bareFileName);
     form.append("text", CONFIG.UPLOAD_TEXT);
     form.append("comment", CONFIG.UPLOAD_COMMENT);
     form.append("token", token);
     form.append("ignorewarnings", "0");
     form.append("format", "json");
     form.append("file", imageBuffer, {
-      filename: fileName.split(":").pop() || fileName,
+      filename: bareFileName,
       contentType: imageResponse.headers.get("content-type") || "application/octet-stream"
     });
     const rawResponse = await targetBot.rawRequest({
@@ -981,7 +985,7 @@ async function syncPages(oldSite, newSite) {
   }
 }
 __name(syncPages, "syncPages");
-async function incrementalUpdate(oldSite, newSite, config) {
+async function incrementalUpdate(oldSite, newSite, config, onSynced) {
   try {
     const now = /* @__PURE__ */ new Date();
     const threeHoursAgo = new Date(now.getTime() - 3 * 60 * 60 * 1e3);
@@ -999,6 +1003,7 @@ async function incrementalUpdate(oldSite, newSite, config) {
     const processedTitles = /* @__PURE__ */ new Set();
     let totalProcessed = 0;
     let totalSkipped = 0;
+    const syncedItems = [];
     for await (const res of queryGen) {
       const pages = res.query?.recentchanges || [];
       for (const page of pages) {
@@ -1019,19 +1024,45 @@ async function incrementalUpdate(oldSite, newSite, config) {
         processedTitles.add(title);
         totalProcessed++;
         try {
+          const rcUser = page.user || "未知";
+          const rcTimestamp = page.timestamp || "";
+          const rcComment = page.comment || "";
           if (title.startsWith(CONFIG2.FILE_NAMESPACE_PREFIX)) {
             const fileName = title.replace(CONFIG2.FILE_NAMESPACE_PREFIX, "");
             logger.info(
               `[增量更新流程] 🖼️  检查到图片: ${title}，正在尝试转存`
             );
-            await syncSingleImage(oldSite, newSite, fileName, config);
+            const result = await syncSingleImage(
+              oldSite,
+              newSite,
+              fileName,
+              config
+            );
+            if (result.success && result.reason === "synced") {
+              syncedItems.push({
+                title,
+                type: "image",
+                user: rcUser,
+                timestamp: rcTimestamp,
+                comment: rcComment
+              });
+            }
           } else {
-            await syncSinglePage(
+            const result = await syncSinglePage(
               oldSite,
               newSite,
               title,
-              CONFIG2.INCREMENTAL_USER
+              rcUser
             );
+            if (result.success && result.reason === "synced") {
+              syncedItems.push({
+                title,
+                type: "page",
+                user: rcUser,
+                timestamp: rcTimestamp,
+                comment: rcComment
+              });
+            }
           }
           await (0, import_koishi6.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
         } catch (error) {
@@ -1042,8 +1073,11 @@ async function incrementalUpdate(oldSite, newSite, config) {
       }
     }
     logger.info(
-      `[增量更新流程] ✅ 增量更新完成！处理: ${totalProcessed}, 跳过: ${totalSkipped}`
+      `[增量更新流程] ✅ 增量更新完成！处理: ${totalProcessed}, 跳过: ${totalSkipped}, 通知: ${syncedItems.length}`
     );
+    if (syncedItems.length > 0) {
+      onSynced?.(syncedItems);
+    }
   } catch (globalError) {
     logger.error(`[增量更新流程] 💥 增量更新流程异常终止:`, globalError);
     throw globalError;
@@ -1218,21 +1252,40 @@ async function syncModules(oldSite, newSite) {
 __name(syncModules, "syncModules");
 
 // src/plugins/syncCommands.ts
+function formatWikiTime(isoString) {
+  try {
+    const date = new Date(isoString);
+    if (Number.isNaN(date.getTime())) return isoString;
+    const pad = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "pad");
+    const y = date.getFullYear();
+    const m = pad(date.getMonth() + 1);
+    const d = pad(date.getDate());
+    const hh = pad(date.getHours());
+    const mm = pad(date.getMinutes());
+    return `${y}-${m}-${d} ${hh}:${mm}`;
+  } catch {
+    return isoString;
+  }
+}
+__name(formatWikiTime, "formatWikiTime");
 var SyncCommands = class {
   static {
     __name(this, "SyncCommands");
   }
   static inject = ["wikiBot", "cron"];
   config;
+  notifyFn;
   constructor(ctx, config) {
     this.config = config;
     logger.info("WikiBot 服务已就绪，初始化定时任务和指令");
+    this.notifyFn = this.buildNotifyFn(ctx);
     ctx.cron("15 * * * *", async () => {
       if (!await this.ensureBotsReady(ctx, "增量更新")) return;
       await incrementalUpdate(
         ctx.wikiBot.getGGBot(),
         ctx.wikiBot.getBWikiBot(),
-        config
+        config,
+        this.notifyFn
       );
     });
     ctx.cron("30 8 * * 4", async () => {
@@ -1257,6 +1310,86 @@ var SyncCommands = class {
     });
     this.registerCommands(ctx);
   }
+  /**
+   * 规范化 channelId：兼容多种前缀格式
+   */
+  normalizeChannelId(rawId) {
+    const trimmed = rawId.trim();
+    if (!trimmed) return "";
+    const lower = trimmed.toLowerCase();
+    if (lower.startsWith("group:")) return trimmed.slice(6);
+    if (lower.startsWith("channel:")) return trimmed.slice(8);
+    if (lower.startsWith("qq:")) return trimmed.slice(3);
+    return trimmed;
+  }
+  /**
+   * 截断摘要到指定长度，超出部分用 ...
+   */
+  truncateComment(text, max = 10) {
+    if (!text) return "";
+    const clean = text.trim();
+    if (clean.length <= max) return clean;
+    return clean.slice(0, max) + "...";
+  }
+  /**
+   * 构建增量更新同步成功的通知回调
+   * 当配置了 notifyGroupIds 时，将同步成功的页面/图片合并成一条消息推送到指定 QQ 群
+   */
+  buildNotifyFn(ctx) {
+    const groupIds = this.config.notifyGroupIds;
+    if (!groupIds || groupIds.length === 0) return void 0;
+    const platform = this.config.notifyBotPlatform || "qq";
+    const self = this;
+    return async (items) => {
+      try {
+        if (!items || items.length === 0) return;
+        const bots = [];
+        for (const bot of ctx.bots) {
+          if (bot.platform === platform && bot.isActive) {
+            bots.push(bot);
+          }
+        }
+        if (bots.length === 0) {
+          logger.warn(`[通知] 未找到可用的 ${platform} 平台 bot，跳过群通知`);
+          return;
+        }
+        const lines = [];
+        lines.push(`Wiki 同步更新（${items.length} 条）`);
+        lines.push("");
+        for (let i = 0; i < items.length; i++) {
+          const item = items[i];
+          const label = item.type === "image" ? "🖼️" : "📖";
+          const zhTime = item.timestamp ? formatWikiTime(item.timestamp) : "";
+          const user = item.user || "未知";
+          const shortComment = self.truncateComment(item.comment || "", 10);
+          const commentLine = shortComment ? `｜${shortComment}` : "";
+          lines.push(
+            `${label} ${i + 1}. ${item.title}｜${user}｜${zhTime}${commentLine}`
+          );
+        }
+        const message = lines.join("\n");
+        for (const bot of bots) {
+          for (const rawChannelId of groupIds) {
+            const channelId = self.normalizeChannelId(rawChannelId);
+            if (!channelId) continue;
+            try {
+              await bot.sendMessage(channelId, message);
+              logger.info(
+                `[通知] 向 ${bot.platform}/${channelId} 推送成功 (${items.length} 条)`
+              );
+            } catch (error) {
+              logger.error(
+                `[通知] 向 ${bot.platform}/${channelId} 发送消息失败:`,
+                getErrorMessage(error)
+              );
+            }
+          }
+        }
+      } catch (error) {
+        logger.error(`[通知] 处理通知过程出错:`, getErrorMessage(error));
+      }
+    };
+  }
   /**
    * 确保机器人就绪，如果未就绪则尝试重新登录
    * @param ctx Koishi 上下文
@@ -1311,7 +1444,8 @@ var SyncCommands = class {
         await incrementalUpdate(
           ctx.wikiBot.getGGBot(),
           ctx.wikiBot.getBWikiBot(),
-          this.config
+          this.config,
+          this.notifyFn
         );
         return `✅ 已尝试获取三小时前的编辑并同步，请前往控制台查看：${this.config.logsUrl}`;
       } catch (err) {
@@ -1406,7 +1540,11 @@ var SyncCommands = class {
     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")
+    logsUrl: import_koishi8.Schema.string().description("日志查看地址").default("https://klei.vip/onilogs"),
+    notifyGroupIds: import_koishi8.Schema.array(import_koishi8.Schema.string()).description(
+      '增量更新同步成功时通知的群频道ID列表，如 ["group:123456"]，留空则不发送通知'
+    ).default([]),
+    notifyBotPlatform: import_koishi8.Schema.string().description("通知 bot 的平台标识，默认 qq").default("qq")
   });
 })(SyncCommands || (SyncCommands = {}));
 
@@ -1715,45 +1853,65 @@ bwiki: https://${this.config.domain}/bw/${match.id}`;
 // src/plugins/updateCommands.ts
 var import_koishi10 = require("koishi");
 var UpdateCommands = class {
+  constructor(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+    this.log = ctx.logger("oni-sync");
+    this.registerCommands(ctx);
+    this.registerCronJobs(ctx);
+  }
   static {
     __name(this, "UpdateCommands");
   }
-  static inject = ["database", "wikiBot"];
+  static inject = ["database", "wikiBot", "cron"];
   config;
   log;
-  constructor(ctx, config) {
-    this.config = config;
-    this.log = ctx.logger("oni-sync");
-    this.registerCommands(ctx);
+  registerCronJobs(ctx) {
+    const cronExpression = this.config.updateCron || "0 2 * * *";
+    ctx.cron(cronExpression, async () => {
+      if (!this.ctx.wikiBot.isReady) {
+        this.log.warn("定时任务：WikiBot 服务未就绪，跳过页面缓存更新");
+        return;
+      }
+      this.log.info("定时任务：开始每日自动更新本地页面缓存（主站）");
+      try {
+        const result = await this.updatePageCache();
+        this.log.info(`定时任务完成：更新 ${result.count} 条页面到本地缓存`);
+      } catch (err) {
+        this.log.error("定时任务失败：自动更新页面缓存", err);
+      }
+    });
+  }
+  async updatePageCache() {
+    const res = await this.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 this.ctx.database.upsert("wikipages", pageData);
+    }
+    logger.info(`检索到 ${pages.length} 个页面，已更新至数据库`);
+    return { count: pages.length };
   }
   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} 个页面，已更新至数据库`);
+        const result = await this.updatePageCache();
+        session.send(`✅ 检索到 ${result.count} 个页面，已更新至数据库`);
       } catch (err) {
         this.log.error("主站缓存更新失败", err);
         session.send("❌ 主站缓存更新失败，请联系管理员查看日志");
@@ -1826,7 +1984,8 @@ var UpdateCommands = class {
 };
 ((UpdateCommands2) => {
   UpdateCommands2.Config = import_koishi10.Schema.object({
-    logsUrl: import_koishi10.Schema.string().description("日志查看地址").default("https://klei.vip/onilogs")
+    logsUrl: import_koishi10.Schema.string().description("日志查看地址").default("https://klei.vip/onilogs"),
+    updateCron: import_koishi10.Schema.string().description("页面缓存自动更新 cron 表达式（默认每天凌晨 2 点）").default("0 2 * * *")
   });
 })(UpdateCommands || (UpdateCommands = {}));
 

package/lib/plugins/syncCommands.d.ts

@@ -8,11 +8,27 @@ export interface SyncCommandsConfig {
     domain: string;
     main_site: string;
     bwiki_site: string;
+    notifyGroupIds?: string[];
+    notifyBotPlatform?: string;
 }
 export declare class SyncCommands {
     static readonly inject: string[];
     config: SyncCommandsConfig;
+    private notifyFn?;
     constructor(ctx: Context, config: SyncCommandsConfig);
+    /**
+     * 规范化 channelId：兼容多种前缀格式
+     */
+    private normalizeChannelId;
+    /**
+     * 截断摘要到指定长度，超出部分用 ...
+     */
+    private truncateComment;
+    /**
+     * 构建增量更新同步成功的通知回调
+     * 当配置了 notifyGroupIds 时，将同步成功的页面/图片合并成一条消息推送到指定 QQ 群
+     */
+    private buildNotifyFn;
     /**
      * 确保机器人就绪，如果未就绪则尝试重新登录
      * @param ctx Koishi 上下文

package/lib/plugins/updateCommands.d.ts

@@ -1,12 +1,16 @@
 import { Context, Logger, Schema } from "koishi";
 export interface UpdateCommandsConfig {
     logsUrl: string;
+    updateCron?: string;
 }
 export declare class UpdateCommands {
+    ctx: Context;
     static readonly inject: string[];
     config: UpdateCommandsConfig;
     log: Logger;
     constructor(ctx: Context, config: UpdateCommandsConfig);
+    private registerCronJobs;
+    private updatePageCache;
     private registerCommands;
 }
 export declare namespace UpdateCommands {

package/lib/services/wikiBotService.d.ts

@@ -36,6 +36,8 @@ export declare class WikiBotService extends Service {
     isGGBotReady(): boolean;
     isBWikiBotReady(): boolean;
     private createBotProxy;
+    private ggbotProxy;
+    private bwikibotProxy;
     getGGBot(): Mwn;
     getBWikiBot(): Mwn;
 }

package/lib/sync/pageSync.d.ts

@@ -20,11 +20,22 @@ declare function syncSinglePage(oldSite: Mwn, newSite: Mwn, pageTitle: string, u
  * @returns null
  */
 declare function syncPages(oldSite: Mwn, newSite: Mwn): Promise<void>;
+/**
+ * 同步成功事件信息
+ */
+export interface SyncNotifyItem {
+    title: string;
+    type: "page" | "image";
+    user?: string;
+    timestamp?: string;
+    comment?: string;
+}
 /**
  * 增量更新
  * @param oldSite 源站点机器人实例
  * @param newSite 目标站点机器人实例
  * @param config KOISHI用户配置的项
+ * @param onSynced 同步成功批量回调（仅 reason==="synced" 的条目，函数结束时一次调用）
  */
-declare function incrementalUpdate(oldSite: Mwn, newSite: Mwn, config: Config): Promise<void>;
+declare function incrementalUpdate(oldSite: Mwn, newSite: Mwn, config: Config, onSynced?: (items: SyncNotifyItem[]) => void): Promise<void>;
 export { syncSinglePage, syncPages, incrementalUpdate };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-oni-sync-bot",
   "description": "缺氧Wiki站镜像点同步-测试",
-  "version": "0.8.7",
+  "version": "0.9.0",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -30,10 +30,10 @@
   },
   "dependencies": {
     "@types/node-fetch": "^2.6.13",
-    "form-data": "^4.0.5",
+    "form-data": "^4.0.6",
     "koishi-plugin-cron": "^3.1.0",
-    "mwn": "^3.0.1",
+    "mwn": "^3.0.3",
     "node-fetch": "^3.3.2",
-    "pinyin-pro": "^3.28.0"
+    "pinyin-pro": "^3.28.1"
   }
 }