koishi-plugin-oni-sync-bot 0.0.2 → 0.0.3

package/lib/index.js

@@ -36,11 +36,60 @@ __export(src_exports, {
   name: () => name
 });
 module.exports = __toCommonJS(src_exports);
-var import_koishi4 = require("koishi");
+var import_koishi5 = require("koishi");
 var import_path = require("path");
 
 // src/utils/login.ts
 var import_mwn = require("mwn");
+
+// src/utils/tools.ts
+var import_koishi = require("koishi");
+var import_pinyin_pro = require("pinyin-pro");
+var CROSS_SITE_LINK_REGEX = /\[\[(en|ru|pt-br):[^\]]*\]\]/g;
+var DEV_TEXT_REGEX = /Dev:/g;
+var MODULE_NAMESPACE_PREFIX = "Module:Dev/";
+function clean_page_text(text) {
+  const textWithoutCrossLink = text.replace(CROSS_SITE_LINK_REGEX, "");
+  const textWithReplacedDev = textWithoutCrossLink.replace(
+    DEV_TEXT_REGEX,
+    MODULE_NAMESPACE_PREFIX
+  );
+  return textWithReplacedDev;
+}
+__name(clean_page_text, "clean_page_text");
+async function getAndProcessPageContent(site, pageTitle) {
+  try {
+    const res = await site.read(pageTitle);
+    const rawText = res.revisions[0]?.content || "";
+    const processedText = clean_page_text(rawText);
+    return processedText.trimEnd();
+  } catch (err) {
+    throw new Error(`[${pageTitle}] 内容获取失败: ${err}`);
+  }
+}
+__name(getAndProcessPageContent, "getAndProcessPageContent");
+function generatePinyinInfo(text) {
+  if (!text) return { pinyin_full: "", pinyin_first: "" };
+  const cleanText = text.replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
+  if (!cleanText) return { pinyin_full: "", pinyin_first: "" };
+  const fullPinyin = (0, import_pinyin_pro.pinyin)(cleanText, {
+    toneType: "none",
+    type: "string",
+    separator: ""
+  }).toLowerCase();
+  const firstLetter = (0, import_pinyin_pro.pinyin)(cleanText, {
+    pattern: "initial",
+    separator: ""
+  }).toLowerCase();
+  return {
+    pinyin_full: fullPinyin,
+    pinyin_first: firstLetter
+  };
+}
+__name(generatePinyinInfo, "generatePinyinInfo");
+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,
@@ -61,7 +110,7 @@ async function login(siteConfig) {
   }
   bot.setRequestOptions(customRequestOptions);
   await bot.login();
-  console.log(`✅ 成功登录 ${siteConfig.name}`);
+  logger.info(`✅ 成功登录 ${siteConfig.name}`);
   return bot;
 }
 __name(login, "login");
@@ -89,56 +138,11 @@ function getSitesConfig(config) {
 }
 __name(getSitesConfig, "getSitesConfig");
 
-// src/utils/tools.ts
-var import_pinyin_pro = require("pinyin-pro");
-var CROSS_SITE_LINK_REGEX = /\[\[(en|ru|pt-br):[^\]]*\]\]/g;
-var DEV_TEXT_REGEX = /Dev:/g;
-var MODULE_NAMESPACE_PREFIX = "Module:Dev/";
-function clean_page_text(text) {
-  const textWithoutCrossLink = text.replace(CROSS_SITE_LINK_REGEX, "");
-  const textWithReplacedDev = textWithoutCrossLink.replace(
-    DEV_TEXT_REGEX,
-    MODULE_NAMESPACE_PREFIX
-  );
-  return textWithReplacedDev;
-}
-__name(clean_page_text, "clean_page_text");
-async function getAndProcessPageContent(site, pageTitle) {
-  try {
-    const res = await site.read(pageTitle);
-    const rawText = res.revisions[0]?.content || "";
-    const processedText = clean_page_text(rawText);
-    return processedText.trimEnd();
-  } catch (err) {
-    throw new Error(`[${pageTitle}] 内容获取失败: ${err}`);
-  }
-}
-__name(getAndProcessPageContent, "getAndProcessPageContent");
-function generatePinyinInfo(text) {
-  if (!text) return { pinyin_full: "", pinyin_first: "" };
-  const cleanText = text.replace(/[^\u4e00-\u9fa5a-zA-Z0-9]/g, "");
-  if (!cleanText) return { pinyin_full: "", pinyin_first: "" };
-  const fullPinyin = (0, import_pinyin_pro.pinyin)(cleanText, {
-    toneType: "none",
-    type: "string",
-    separator: ""
-  }).toLowerCase();
-  const firstLetter = (0, import_pinyin_pro.pinyin)(cleanText, {
-    pattern: "initial",
-    separator: ""
-  }).toLowerCase();
-  return {
-    pinyin_full: fullPinyin,
-    pinyin_first: firstLetter
-  };
-}
-__name(generatePinyinInfo, "generatePinyinInfo");
-
 // src/sync/pageSync.ts
-var import_koishi2 = require("koishi");
+var import_koishi3 = require("koishi");
 
 // src/sync/imgSync.ts
-var import_koishi = require("koishi");
+var import_koishi2 = require("koishi");
 var import_node_fetch = __toESM(require("node-fetch"));
 var import_form_data = __toESM(require("form-data"));
 var CONFIG = {
@@ -168,29 +172,29 @@ async function getImageInfo(site, fileName) {
       size: imageInfo.size
     };
   } catch (error) {
-    console.error(`[GetImageInfo] 获取 ${fileName} 信息失败:`, error);
+    logger.error(`[GetImageInfo] 获取 ${fileName} 信息失败:`, error);
     return null;
   }
 }
 __name(getImageInfo, "getImageInfo");
 async function syncSingleImage(sourceBot, targetBot, fileName, config) {
   if (CONFIG.IGNORED_IMAGES.includes(fileName)) {
-    console.log(`[SyncImg] 🚫 图片 ${fileName} 在忽略列表，跳过`);
+    logger.info(`[SyncImg] 🚫 图片 ${fileName} 在忽略列表，跳过`);
     return { success: true, reason: "ignored" };
   }
   try {
-    console.log(`[SyncImg] 🚀 开始处理: ${fileName}`);
+    logger.info(`[SyncImg] 🚀 开始处理: ${fileName}`);
     const sourceImageInfo = await getImageInfo(sourceBot, fileName);
     if (!sourceImageInfo) {
-      console.log(`[SyncImg] ❌ 源站未找到图片: ${fileName}`);
+      logger.info(`[SyncImg] ❌ 源站未找到图片: ${fileName}`);
       return { success: false, reason: "source_missing" };
     }
     const targetImageInfo = await getImageInfo(targetBot, fileName);
     if (targetImageInfo && targetImageInfo.sha1 === sourceImageInfo.sha1) {
-      console.log(`[SyncImg] 🟡 图片 ${fileName} 已存在且内容一致，跳过`);
+      logger.info(`[SyncImg] 🟡 图片 ${fileName} 已存在且内容一致，跳过`);
       return { success: true, reason: "no_change" };
     }
-    console.log(`[SyncImg] 📥 下载图片: ${sourceImageInfo.url}`);
+    logger.info(`[SyncImg] 📥 下载图片: ${sourceImageInfo.url}`);
     const imageResponse = await (0, import_node_fetch.default)(sourceImageInfo.url, {
       headers: {
         "User-Agent": "OniSyncBot/1.0 (https://klei.vip; Charles@klei.vip)"
@@ -200,7 +204,7 @@ async function syncSingleImage(sourceBot, targetBot, fileName, config) {
       throw new Error(`图片下载失败，HTTP状态码: ${imageResponse.status}`);
     }
     const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
-    console.log(
+    logger.info(
       `[SyncImg] 📤 上传图片: ${fileName} (大小: ${(imageBuffer.length / 1024).toFixed(1)} KB)`
     );
     const token = await targetBot.getCsrfToken();
@@ -227,7 +231,7 @@ async function syncSingleImage(sourceBot, targetBot, fileName, config) {
     });
     const responseData = rawResponse.data;
     if (responseData.upload && responseData.upload.result === "Success") {
-      console.log(`[SyncImg] ✅ 图片 ${fileName} 同步成功`);
+      logger.info(`[SyncImg] ✅ 图片 ${fileName} 同步成功`);
       return { success: true, reason: "synced" };
     } else if (responseData.error) {
       throw new Error(`${responseData.error.code}: ${responseData.error.info}`);
@@ -236,13 +240,13 @@ async function syncSingleImage(sourceBot, targetBot, fileName, config) {
     }
   } catch (error) {
     const errMsg = error.message || String(error);
-    console.error(`[SyncImg] ❌ 图片 ${fileName} 同步失败:`, errMsg);
+    logger.error(`[SyncImg] ❌ 图片 ${fileName} 同步失败:`, errMsg);
     return { success: false, reason: errMsg };
   }
 }
 __name(syncSingleImage, "syncSingleImage");
 async function getAllImages(site) {
-  console.log(`[SyncAllImg] 📥 开始获取WikiGG所有图片`);
+  logger.info(`[SyncAllImg] 📥 开始获取WikiGG所有图片`);
   const allImages = [];
   const queryGen = site.continuedQueryGen({
     action: "query",
@@ -255,9 +259,9 @@ async function getAllImages(site) {
     const imageItems = res.query?.allimages || [];
     const imageTitles = imageItems.map((img) => img.title);
     allImages.push(...imageTitles);
-    console.log(`[SyncAllImg] 📄 已获取 ${allImages.length} 个图片`);
+    logger.info(`[SyncAllImg] 📄 已获取 ${allImages.length} 个图片`);
   }
-  console.log(`[SyncAllImg] 📊 总计获取到 ${allImages.length} 个图片`);
+  logger.info(`[SyncAllImg] 📊 总计获取到 ${allImages.length} 个图片`);
   return allImages;
 }
 __name(getAllImages, "getAllImages");
@@ -265,20 +269,20 @@ async function syncAllImages(sourceBot, targetBot, config) {
   try {
     const imageList = await getAllImages(sourceBot);
     if (imageList.length === 0) {
-      console.log(`[SyncAllImg] 📭 源站无图片可同步，结束`);
+      logger.info(`[SyncAllImg] 📭 源站无图片可同步，结束`);
       return;
     }
     let successCount = 0;
     let failCount = 0;
     let skipCount = 0;
     const failedImages = [];
-    console.log(
+    logger.info(
       `[SyncAllImg] 🚦 开始批量同步，总计 ${imageList.length} 个图片`
     );
     for (let i = 0; i < imageList.length; i++) {
       const fileName = imageList[i];
       const progress = (i + 1) / imageList.length * 100;
-      console.log(
+      logger.info(
         `
 [SyncAllImg] 📈 进度 ${i + 1}/${imageList.length} (${progress.toFixed(1)}%)`
       );
@@ -291,23 +295,23 @@ async function syncAllImages(sourceBot, targetBot, config) {
       if (!result.success) {
         failCount++;
         failedImages.push(fileName);
-        await (0, import_koishi.sleep)(CONFIG.SYNC_INTERVAL_FAILED);
+        await (0, import_koishi2.sleep)(CONFIG.SYNC_INTERVAL_FAILED);
       } else {
         successCount++;
         if (result.reason === "ignored" || result.reason === "no_change") {
           skipCount++;
         }
-        await (0, import_koishi.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
+        await (0, import_koishi2.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
       }
     }
     if (failedImages.length > 0) {
-      console.log(
+      logger.info(
         `
 [SyncAllImg] 🔄 开始重试 ${failedImages.length} 个失败图片`
       );
       const stillFailed = [];
       for (const fileName of failedImages) {
-        console.log(`
+        logger.info(`
 [SyncAllImg] 🔁 重试: ${fileName}`);
         const result = await syncSingleImage(
           sourceBot,
@@ -318,31 +322,31 @@ async function syncAllImages(sourceBot, targetBot, config) {
         if (result.success) {
           successCount++;
           failCount--;
-          console.log(`[SyncAllImg] ✅ 重试成功: ${fileName}`);
+          logger.info(`[SyncAllImg] ✅ 重试成功: ${fileName}`);
         } else {
           stillFailed.push(fileName);
-          console.log(`[SyncAllImg] ❌ 重试失败: ${fileName}`);
+          logger.info(`[SyncAllImg] ❌ 重试失败: ${fileName}`);
         }
-        await (0, import_koishi.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
+        await (0, import_koishi2.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
       }
       if (stillFailed.length > 0) {
-        console.log(`
+        logger.info(`
 [SyncAllImg] ❌ 最终失败列表（需手动处理）:`);
         stillFailed.forEach(
-          (title, idx) => console.log(`  ${idx + 1}. ${title}`)
+          (title, idx) => logger.info(`  ${idx + 1}. ${title}`)
         );
       } else {
-        console.log(`
+        logger.info(`
 [SyncAllImg] 🎉 所有失败图片重试成功！`);
       }
     }
-    console.log(`
+    logger.info(`
 [SyncAllImg] 📊 同步完成！`);
-    console.log(`├─ 总计：${imageList.length} 个图片`);
-    console.log(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
-    console.log(`└─ 失败：${failCount} 个`);
+    logger.info(`├─ 总计：${imageList.length} 个图片`);
+    logger.info(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
+    logger.info(`└─ 失败：${failCount} 个`);
   } catch (globalError) {
-    console.error(`[SyncAllImg] 💥 同步流程异常终止:`, globalError);
+    logger.error(`[SyncAllImg] 💥 同步流程异常终止:`, globalError);
     throw globalError;
   }
 }
@@ -361,31 +365,31 @@ var CONFIG2 = {
 };
 async function syncSinglePage(oldSite, newSite, pageTitle, user) {
   if (CONFIG2.IGNORED_PAGES.has(pageTitle)) {
-    console.log(`[syncSinglePage] 🚫 页面 ${pageTitle} 在忽略列表中，跳过`);
+    logger.info(`[syncSinglePage] 🚫 页面 ${pageTitle} 在忽略列表中，跳过`);
     return { success: true, reason: "ignored" };
   }
   try {
-    console.log(`[syncSinglePage] 🚀 开始同步页面: ${pageTitle}`);
+    logger.info(`[syncSinglePage] 🚀 开始同步页面: ${pageTitle}`);
     const [oldContent, newContent] = await Promise.all([
       getAndProcessPageContent(oldSite, pageTitle),
       getAndProcessPageContent(newSite, pageTitle)
     ]);
     if (oldContent === newContent) {
-      console.log(`[syncSinglePage] 🟡 页面 ${pageTitle} 内容未改变，跳过`);
+      logger.info(`[syncSinglePage] 🟡 页面 ${pageTitle} 内容未改变，跳过`);
       return { success: true, reason: "no_change" };
     }
     await newSite.save(pageTitle, oldContent, `由：${user} 触发更改，此时同步`);
-    console.log(`[syncSinglePage] ✅ 页面 ${pageTitle} 同步成功`);
+    logger.info(`[syncSinglePage] ✅ 页面 ${pageTitle} 同步成功`);
     return { success: true, reason: "synced" };
   } catch (error) {
     const errMsg = error instanceof Error ? error.message : String(error);
-    console.error(`[syncSinglePage] ❌ 页面 ${pageTitle} 同步失败:`, errMsg);
+    logger.error(`[syncSinglePage] ❌ 页面 ${pageTitle} 同步失败:`, errMsg);
     return { success: false, reason: errMsg };
   }
 }
 __name(syncSinglePage, "syncSinglePage");
 async function getAllPages(site) {
-  console.log(
+  logger.info(
     `[SyncAllPages] 📥 开始获取原站点所有页面（命名空间${CONFIG2.NAMESPACE}）`
   );
   const allPages = [];
@@ -399,9 +403,9 @@ async function getAllPages(site) {
   for await (const res of queryGen) {
     const pageTitles = res.query?.allpages?.map((page) => page.title) || [];
     allPages.push(...pageTitles);
-    console.log(`[SyncAllPages] 📄 已获取 ${allPages.length} 个页面`);
+    logger.info(`[SyncAllPages] 📄 已获取 ${allPages.length} 个页面`);
   }
-  console.log(`[SyncAllPages] 📊 原站点总计获取到 ${allPages.length} 个页面`);
+  logger.info(`[SyncAllPages] 📊 原站点总计获取到 ${allPages.length} 个页面`);
   return allPages;
 }
 __name(getAllPages, "getAllPages");
@@ -410,41 +414,41 @@ async function processPageWithStats(oldSite, newSite, pageTitle, user, stats, fa
   if (!syncResult.success) {
     stats.failCount++;
     failedPages.push(pageTitle);
-    await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+    await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
   } else {
     stats.successCount++;
     if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
       stats.skipCount++;
     }
-    await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+    await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
   }
 }
 __name(processPageWithStats, "processPageWithStats");
 function printProgress(current, total, pageTitle) {
   const progress = (current / total * 100).toFixed(1);
   const remaining = total - current;
-  console.log(
+  logger.info(
     `
 [SyncAllPages] 📈 进度 [${current}/${total}] (${progress}%) - 处理 ${pageTitle} | 剩余 ${remaining} 个`
   );
 }
 __name(printProgress, "printProgress");
 function printFinalReport(total, successCount, failCount, skipCount, stillFailed) {
-  console.log(`
+  logger.info(`
 [SyncAllPages] 📋 ===== 最终同步报告 =====`);
   if (stillFailed.length > 0) {
-    console.log(`❌ 以下页面经过重试仍然失败，请手动检查：`);
+    logger.info(`❌ 以下页面经过重试仍然失败，请手动检查：`);
     stillFailed.forEach((title, idx) => {
-      console.log(`  ${idx + 1}. ${title}`);
+      logger.info(`  ${idx + 1}. ${title}`);
     });
   } else {
-    console.log(`🎉 所有页面同步成功（含重试）！`);
+    logger.info(`🎉 所有页面同步成功（含重试）！`);
   }
-  console.log(`
+  logger.info(`
 [SyncAllPages] 🎯 同步流程结束！`);
-  console.log(`├─ 总计：${total} 个页面`);
-  console.log(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
-  console.log(`└─ 失败：${failCount} 个`);
+  logger.info(`├─ 总计：${total} 个页面`);
+  logger.info(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
+  logger.info(`└─ 失败：${failCount} 个`);
 }
 __name(printFinalReport, "printFinalReport");
 async function syncPages(oldSite, newSite) {
@@ -452,12 +456,12 @@ async function syncPages(oldSite, newSite) {
     const oldPageList = await getAllPages(oldSite);
     const total = oldPageList.length;
     if (total === 0) {
-      console.log(`[SyncAllPages] 📭 原站点无页面可同步，结束`);
+      logger.info(`[SyncAllPages] 📭 原站点无页面可同步，结束`);
       return;
     }
     const stats = { successCount: 0, failCount: 0, skipCount: 0 };
     const failedPages = [];
-    console.log(`[SyncAllPages] 🚦 开始批量同步，总计 ${total} 个页面`);
+    logger.info(`[SyncAllPages] 🚦 开始批量同步，总计 ${total} 个页面`);
     for (let index = 0; index < total; index++) {
       const pageTitle = oldPageList[index];
       printProgress(index + 1, total, pageTitle);
@@ -472,12 +476,12 @@ async function syncPages(oldSite, newSite) {
     }
     let stillFailed = [];
     if (failedPages.length > 0) {
-      console.log(
+      logger.info(
         `
 [SyncAllPages] 🔄 ===== 开始重试 ${failedPages.length} 个失败页面 =====`
       );
       for (const pageTitle of failedPages) {
-        console.log(`
+        logger.info(`
 [SyncAllPages] 🔁 重试中: ${pageTitle}`);
         const syncResult = await syncSinglePage(
           oldSite,
@@ -491,12 +495,12 @@ async function syncPages(oldSite, newSite) {
           if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
             stats.skipCount++;
           }
-          console.log(`[SyncAllPages] ✅ 页面 ${pageTitle} 重试成功`);
-          await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+          logger.info(`[SyncAllPages] ✅ 页面 ${pageTitle} 重试成功`);
+          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
         } else {
           stillFailed.push(pageTitle);
-          console.log(`[SyncAllPages] ❌ 页面 ${pageTitle} 再次失败`);
-          await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+          logger.info(`[SyncAllPages] ❌ 页面 ${pageTitle} 再次失败`);
+          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
         }
       }
     }
@@ -508,7 +512,7 @@ async function syncPages(oldSite, newSite) {
       stillFailed
     );
   } catch (globalError) {
-    console.error(`[SyncAllPages] 💥 批量同步流程异常终止:`, globalError);
+    logger.error(`[SyncAllPages] 💥 批量同步流程异常终止:`, globalError);
     throw globalError;
   }
 }
@@ -517,7 +521,7 @@ async function incrementalUpdate(oldSite, newSite, config) {
   try {
     const now = /* @__PURE__ */ new Date();
     const threeHoursAgo = new Date(now.getTime() - 3 * 60 * 60 * 1e3);
-    console.log(
+    logger.info(
       `[增量更新流程] ⏰ 开始处理 ${threeHoursAgo.toISOString()} 到 ${now.toISOString()} 的更新...`
     );
     const queryGen = oldSite.continuedQueryGen({
@@ -536,12 +540,12 @@ async function incrementalUpdate(oldSite, newSite, config) {
       for (const page of pages) {
         const title = page.title;
         if (processedTitles.has(title)) {
-          console.log(`[增量更新流程] ⏭️  已经处理过 ${title}, 跳过`);
+          logger.info(`[增量更新流程] ⏭️  已经处理过 ${title}, 跳过`);
           totalSkipped++;
           continue;
         }
         if (CONFIG2.IGNORED_PAGES.has(title)) {
-          console.log(
+          logger.info(
             `[增量更新流程] 🚫 ${title} 在无需处理的页面列表中, 跳过`
           );
           processedTitles.add(title);
@@ -553,7 +557,7 @@ async function incrementalUpdate(oldSite, newSite, config) {
         try {
           if (title.startsWith(CONFIG2.FILE_NAMESPACE_PREFIX)) {
             const fileName = title.replace(CONFIG2.FILE_NAMESPACE_PREFIX, "");
-            console.log(
+            logger.info(
               `[增量更新流程] 🖼️  检查到图片: ${title}，正在尝试转存`
             );
             await syncSingleImage(oldSite, newSite, fileName, config);
@@ -565,26 +569,26 @@ async function incrementalUpdate(oldSite, newSite, config) {
               CONFIG2.INCREMENTAL_USER
             );
           }
-          await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
         } catch (error) {
           const errMsg = error instanceof Error ? error.message : String(error);
-          console.error(`[增量更新流程] ❌ 处理 ${title} 时出错:`, errMsg);
-          await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+          logger.error(`[增量更新流程] ❌ 处理 ${title} 时出错:`, errMsg);
+          await (0, import_koishi3.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
         }
       }
     }
-    console.log(
+    logger.info(
       `[增量更新流程] ✅ 增量更新完成！处理: ${totalProcessed}, 跳过: ${totalSkipped}`
     );
   } catch (globalError) {
-    console.error(`[增量更新流程] 💥 增量更新流程异常终止:`, globalError);
+    logger.error(`[增量更新流程] 💥 增量更新流程异常终止:`, globalError);
     throw globalError;
   }
 }
 __name(incrementalUpdate, "incrementalUpdate");
 
 // src/sync/moduleSync.ts
-var import_koishi3 = require("koishi");
+var import_koishi4 = require("koishi");
 var CONFIG3 = {
   MODLE_NAMESPACE: 828,
   // 模块命名空间 (注意：这里原代码拼写为 MODLE，保留原样)
@@ -597,17 +601,17 @@ var CONFIG3 = {
 };
 async function syncSingleModule(oldSite, newSite, moduleTitle, user) {
   if (CONFIG3.IGNORED_MODULES.includes(moduleTitle)) {
-    console.log(`[SyncModule] 🚫 模块 ${moduleTitle} 在忽略列表中，跳过`);
+    logger.info(`[SyncModule] 🚫 模块 ${moduleTitle} 在忽略列表中，跳过`);
     return { success: true, reason: "ignored" };
   }
   try {
-    console.log(`[SyncModule] 🔍 开始获取模块 ${moduleTitle} 的内容`);
+    logger.info(`[SyncModule] 🔍 开始获取模块 ${moduleTitle} 的内容`);
     const [oldContent, newContent] = await Promise.all([
       getAndProcessPageContent(oldSite, moduleTitle),
       getAndProcessPageContent(newSite, moduleTitle)
     ]);
     if (oldContent === newContent) {
-      console.log(`[SyncModule] 🟡 模块 ${moduleTitle} 内容未改变，跳过`);
+      logger.info(`[SyncModule] 🟡 模块 ${moduleTitle} 内容未改变，跳过`);
       return { success: true, reason: "no_change" };
     }
     await newSite.save(
@@ -615,17 +619,17 @@ async function syncSingleModule(oldSite, newSite, moduleTitle, user) {
       oldContent,
       `由：${user || "同步坤器人手动"} 触发更改，此时同步`
     );
-    console.log(`[SyncModule] ✅ 模块 ${moduleTitle} 同步成功`);
+    logger.info(`[SyncModule] ✅ 模块 ${moduleTitle} 同步成功`);
     return { success: true, reason: "synced" };
   } catch (error) {
     const errMsg = error.message || String(error);
-    console.error(`[SyncModule] ❌ 模块 ${moduleTitle} 同步失败:`, errMsg);
+    logger.error(`[SyncModule] ❌ 模块 ${moduleTitle} 同步失败:`, errMsg);
     return { success: false, reason: errMsg };
   }
 }
 __name(syncSingleModule, "syncSingleModule");
 async function getAllModules(site) {
-  console.log(
+  logger.info(
     `[SyncAllModules] 📥 开始获取原站点所有模块（命名空间${CONFIG3.MODLE_NAMESPACE}）`
   );
   const allModules = [];
@@ -640,9 +644,9 @@ async function getAllModules(site) {
   for await (const res of queryGen) {
     const moduleTitles = res.query?.allpages?.map((page) => page.title) || [];
     allModules.push(...moduleTitles);
-    console.log(`[SyncAllModules] 📄 已获取 ${allModules.length} 个模块`);
+    logger.info(`[SyncAllModules] 📄 已获取 ${allModules.length} 个模块`);
   }
-  console.log(
+  logger.info(
     `[SyncAllModules] 📊 原站点总计获取到 ${allModules.length} 个模块`
   );
   return allModules;
@@ -653,20 +657,20 @@ async function syncModules(oldSite, newSite) {
     const oldModuleList = await getAllModules(oldSite);
     const total = oldModuleList.length;
     if (total === 0) {
-      console.log(`[SyncAllModules] 📭 原站点无模块可同步，结束`);
+      logger.info(`[SyncAllModules] 📭 原站点无模块可同步，结束`);
       return;
     }
     let successCount = 0;
     let failCount = 0;
     let skipCount = 0;
     const failedModules = [];
-    console.log(`[SyncAllModules] 🚦 开始批量同步，总计 ${total} 个模块`);
+    logger.info(`[SyncAllModules] 🚦 开始批量同步，总计 ${total} 个模块`);
     for (let index = 0; index < total; index++) {
       const moduleTitle = oldModuleList[index];
       const current = index + 1;
       const remaining = total - current;
       const progress = (current / total * 100).toFixed(1);
-      console.log(
+      logger.info(
         `
 [SyncAllModules] 📈 进度 [${current}/${total}] (${progress}%) - 处理 ${moduleTitle} | 剩余 ${remaining} 个`
       );
@@ -679,23 +683,23 @@ async function syncModules(oldSite, newSite) {
       if (!syncResult.success) {
         failCount++;
         failedModules.push(moduleTitle);
-        await (0, import_koishi3.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
+        await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
       } else {
         successCount++;
         if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
           skipCount++;
         }
-        await (0, import_koishi3.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
+        await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
       }
     }
     if (failedModules.length > 0) {
-      console.log(
+      logger.info(
         `
 [SyncAllModules] 🔄 ===== 开始重试 ${failedModules.length} 个失败模块 =====`
       );
       const stillFailed = [];
       for (const moduleTitle of failedModules) {
-        console.log(`
+        logger.info(`
 [SyncAllModules] 🔁 重试中: ${moduleTitle}`);
         const syncResult = await syncSingleModule(
           oldSite,
@@ -709,32 +713,32 @@ async function syncModules(oldSite, newSite) {
           if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
             skipCount++;
           }
-          console.log(`[SyncAllModules] ✅ 模块 ${moduleTitle} 重试成功`);
-          await (0, import_koishi3.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
+          logger.info(`[SyncAllModules] ✅ 模块 ${moduleTitle} 重试成功`);
+          await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
         } else {
           stillFailed.push(moduleTitle);
-          console.log(`[SyncAllModules] ❌ 模块 ${moduleTitle} 再次失败`);
-          await (0, import_koishi3.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
+          logger.info(`[SyncAllModules] ❌ 模块 ${moduleTitle} 再次失败`);
+          await (0, import_koishi4.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
         }
       }
-      console.log(`
+      logger.info(`
 [SyncAllModules] 📋 ===== 最终同步报告 =====`);
       if (stillFailed.length > 0) {
-        console.log(`❌ 以下模块经过重试仍然失败，请手动检查：`);
+        logger.info(`❌ 以下模块经过重试仍然失败，请手动检查：`);
         stillFailed.forEach((title, idx) => {
-          console.log(`  ${idx + 1}. ${title}`);
+          logger.info(`  ${idx + 1}. ${title}`);
         });
       } else {
-        console.log(`🎉 所有模块同步成功（含重试）！`);
+        logger.info(`🎉 所有模块同步成功（含重试）！`);
       }
     }
-    console.log(`
+    logger.info(`
 [SyncAllModules] 🎯 同步完成！`);
-    console.log(`├─ 总计：${total} 个模块`);
-    console.log(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
-    console.log(`└─ 失败：${failCount} 个`);
+    logger.info(`├─ 总计：${total} 个模块`);
+    logger.info(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
+    logger.info(`└─ 失败：${failCount} 个`);
   } catch (error) {
-    console.error(`[SyncAllModules] 💥 批量同步流程异常终止:`, error);
+    logger.error(`[SyncAllModules] 💥 批量同步流程异常终止:`, error);
     throw error;
   }
 }
@@ -743,18 +747,18 @@ __name(syncModules, "syncModules");
 // src/index.ts
 var name = "oni-sync-bot";
 var inject = ["console", "database", "server", "cron"];
-var Config = import_koishi4.Schema.object({
-  ggUsername: import_koishi4.Schema.string().description("WIKIGG 用户名").default("${{ env.ggUsername }}"),
-  ggPassword: import_koishi4.Schema.string().description("WIKIGG 密码").default("${{ env.ggPassword }}"),
-  huijiUsername: import_koishi4.Schema.string().description("灰机wiki 用户名").default("${{ env.huijiUsername }}"),
-  huijiPassword: import_koishi4.Schema.string().description("灰机wiki 密码").default("${{ env.huijiPassword }}"),
-  huijiUAKey: import_koishi4.Schema.string().description("灰机wiki UAKey").default("${{ env.huijiUAKey }}"),
-  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"),
-  mirror_site: import_koishi4.Schema.string().description("镜像站域名（必填，如：wiki.biligame.com）").default("wiki.biligame.com/oni")
+var Config = import_koishi5.Schema.object({
+  ggUsername: import_koishi5.Schema.string().description("WIKIGG 用户名").default("${{ env.ggUsername }}"),
+  ggPassword: import_koishi5.Schema.string().description("WIKIGG 密码").default("${{ env.ggPassword }}"),
+  huijiUsername: import_koishi5.Schema.string().description("灰机wiki 用户名").default("${{ env.huijiUsername }}"),
+  huijiPassword: import_koishi5.Schema.string().description("灰机wiki 密码").default("${{ env.huijiPassword }}"),
+  huijiUAKey: import_koishi5.Schema.string().description("灰机wiki UAKey").default("${{ env.huijiUAKey }}"),
+  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"),
+  mirror_site: import_koishi5.Schema.string().description("镜像站域名（必填，如：wiki.biligame.com）").default("wiki.biligame.com/oni")
 });
 function apply(ctx, config) {
-  const logger = ctx.logger("oni-sync-bot");
+  const logger2 = ctx.logger("oni-sync-bot");
   let ggbot;
   let huijibot;
   ctx.inject(["console"], (ctx2) => {
@@ -794,30 +798,30 @@ function apply(ctx, config) {
     router.redirect(targetUrl);
   });
   ctx.on("ready", async () => {
-    logger.info("初始化中...");
+    logger2.info("初始化中...");
     const sitesConfig = getSitesConfig(config);
     ggbot = await login(sitesConfig.gg);
     huijibot = await login(sitesConfig.huiji);
     if (ggbot.login && huijibot.login) {
-      logger.info("登录成功，插件已准备就绪");
+      logger2.info("登录成功，插件已准备就绪");
     } else {
-      logger.error("登录失败，请检查配置");
+      logger2.error("登录失败，请检查配置");
     }
     ctx.cron("15 * * * *", async () => {
       await incrementalUpdate(ggbot, huijibot, config);
     });
     ctx.cron("30 8 * * 4", async () => {
       await syncPages(ggbot, huijibot).then(() => {
-        logger.info("自动任务：尝试同步所有页面，从 WIKIGG 到 灰机wiki");
+        logger2.info("自动任务：尝试同步所有页面，从 WIKIGG 到 灰机wiki");
       }).catch((err) => {
-        logger.error(`同步所有页面失败，错误信息：${err}`);
+        logger2.error(`同步所有页面失败，错误信息：${err}`);
       });
     });
     ctx.cron("30 8 * * 3", async () => {
       await syncAllImages(ggbot, huijibot, config).then(() => {
-        logger.info("自动任务：尝试同步所有图片，从 WIKIGG 到 灰机wiki");
+        logger2.info("自动任务：尝试同步所有图片，从 WIKIGG 到 灰机wiki");
       }).catch((err) => {
-        logger.error(`同步所有图片失败，错误信息：${err}`);
+        logger2.error(`同步所有图片失败，错误信息：${err}`);
       });
     });
   });
@@ -989,7 +993,7 @@ function apply(ctx, config) {
         format: "json",
         aplimit: "max"
       });
-      logger.info("主站页面查询成功");
+      logger2.info("主站页面查询成功");
       const pages = res.query.allpages || [];
       const pageData = pages.map((page) => {
         const { pinyin_full, pinyin_first } = generatePinyinInfo(page.title);
@@ -1004,9 +1008,9 @@ function apply(ctx, config) {
         await ctx.database.upsert("wikipages", pageData);
       }
       session.send(`✅ 检索到 ${pages.length} 个页面，已更新至数据库`);
-      logger.info(`检索到 ${pages.length} 个页面，已更新至数据库`);
+      logger2.info(`检索到 ${pages.length} 个页面，已更新至数据库`);
     } catch (err) {
-      logger.error("主站缓存更新失败", err);
+      logger2.error("主站缓存更新失败", err);
       session.send("❌ 主站缓存更新失败，请联系管理员查看日志");
     }
   });
@@ -1014,9 +1018,9 @@ function apply(ctx, config) {
     try {
       const count = await ctx.database.remove("wikipages", {});
       session.send(`✅ 已删除 ${count.removed} 条本地缓存`);
-      logger.info(`已删除 ${count.removed} 条本地缓存`);
+      logger2.info(`已删除 ${count.removed} 条本地缓存`);
     } catch (err) {
-      logger.error("删除缓存失败", err);
+      logger2.error("删除缓存失败", err);
       session.send("❌ 删除缓存失败，请联系管理员查看日志");
     }
   });
@@ -1024,9 +1028,9 @@ function apply(ctx, config) {
     try {
       const pages = await ctx.database.get("wikipages", {});
       session.send(`📊 数据库中缓存了 ${pages.length} 条页面`);
-      logger.info(`数据库中缓存了 ${pages.length} 条页面`);
+      logger2.info(`数据库中缓存了 ${pages.length} 条页面`);
     } catch (err) {
-      logger.error("查询缓存状态失败", err);
+      logger2.error("查询缓存状态失败", err);
       session.send("❌ 查询缓存状态失败，请联系管理员查看日志");
     }
   });
@@ -1042,11 +1046,11 @@ function apply(ctx, config) {
         `#REDIRECT [[${targetPageName}]]`,
         "来自qq机器人的添加重定向页面请求"
       );
-      logger.info(`已为 ${pageName} 添加重定向至 ${targetPageName}`);
+      logger2.info(`已为 ${pageName} 添加重定向至 ${targetPageName}`);
       session.send(`✅ 已尝试添加重定向 ${pageName} -> ${targetPageName}`);
       await session.execute(`update`);
     } catch (err) {
-      logger.error(`添加重定向 ${pageName} -> ${targetPageName} 失败`, err);
+      logger2.error(`添加重定向 ${pageName} -> ${targetPageName} 失败`, err);
       session.send(`❌ 添加重定向失败，请联系管理员查看日志`);
     }
   });

package/lib/utils/tools.d.ts

@@ -1,3 +1,4 @@
+import { Logger } from "koishi";
 import { Mwn } from "mwn";
 /**
  * 获取并处理页面内容
@@ -15,4 +16,5 @@ declare function generatePinyinInfo(text: string): {
     pinyin_full: string;
     pinyin_first: string;
 };
-export { getAndProcessPageContent, generatePinyinInfo };
+declare const logger: Logger;
+export { getAndProcessPageContent, generatePinyinInfo, logger };

package/package.json

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