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

package/dist/index.js

@@ -0,0 +1 @@
+import{defineComponent as p,resolveComponent as e,openBlock as r,createBlock as u,withCtx as n,createVNode as c,createElementVNode as d}from"vue";const m=p({__name:"page",setup(t){return(s,o)=>{const a=e("k-card-content"),_=e("k-card"),l=e("k-layout");return r(),u(l,null,{default:n(()=>[c(_,null,{default:n(()=>[c(a,null,{default:n(()=>[...o[0]||(o[0]=[d("p",null," 这是想写却不知道咋写的页面 ",-1)])]),_:1})]),_:1})]),_:1})}}}),f=t=>{t.page({name:"同步机器人",path:"/syncbot",component:m})};export{f as default};

package/dist/style.css

@@ -0,0 +1 @@
+

package/lib/index.js

@@ -0,0 +1,1061 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Config: () => Config,
+  apply: () => apply,
+  inject: () => inject,
+  name: () => name
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi4 = require("koishi");
+var import_path = require("path");
+
+// src/utils/login.ts
+var import_mwn = require("mwn");
+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"
+    }
+  });
+  const customRequestOptions = {
+    headers: {
+      "User-Agent": siteConfig.userAgent
+    }
+  };
+  if (siteConfig.uakey) {
+    customRequestOptions.headers["X-authkey"] = siteConfig.uakey;
+  }
+  bot.setRequestOptions(customRequestOptions);
+  await bot.login();
+  console.log(`✅ 成功登录 ${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
+    },
+    huiji: {
+      name: "灰机wiki",
+      api: "https://oni.huijiwiki.com/api.php",
+      username: config.huijiUsername,
+      password: config.huijiPassword,
+      userAgent,
+      uakey: config.huijiUAKey
+    }
+  };
+}
+__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");
+
+// src/sync/imgSync.ts
+var import_koishi = require("koishi");
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_form_data = __toESM(require("form-data"));
+var CONFIG = {
+  IGNORED_IMAGES: [],
+  SYNC_INTERVAL_SUCCESS: 3e3,
+  SYNC_INTERVAL_FAILED: 5e3,
+  UPLOAD_COMMENT: "从 WikiGG 自动同步转存",
+  UPLOAD_TEXT: "== 授权说明 ==\n本文件从 WikiGG 转存，遵循原站点授权协议。"
+};
+async function getImageInfo(site, fileName) {
+  try {
+    const response = await site.query({
+      action: "query",
+      titles: fileName,
+      prop: "imageinfo",
+      iiprop: "url|sha1|size|mime"
+    });
+    const pages = response.query?.pages || {};
+    const page = Object.values(pages)[0];
+    if (!page || page.missing || !page.imageinfo || page.imageinfo.length === 0) {
+      return null;
+    }
+    const imageInfo = page.imageinfo[0];
+    return {
+      url: imageInfo.url,
+      sha1: imageInfo.sha1,
+      size: imageInfo.size
+    };
+  } catch (error) {
+    console.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} 在忽略列表，跳过`);
+    return { success: true, reason: "ignored" };
+  }
+  try {
+    console.log(`[SyncImg] 🚀 开始处理: ${fileName}`);
+    const sourceImageInfo = await getImageInfo(sourceBot, fileName);
+    if (!sourceImageInfo) {
+      console.log(`[SyncImg] ❌ 源站未找到图片: ${fileName}`);
+      return { success: false, reason: "source_missing" };
+    }
+    const targetImageInfo = await getImageInfo(targetBot, fileName);
+    if (targetImageInfo && targetImageInfo.sha1 === sourceImageInfo.sha1) {
+      console.log(`[SyncImg] 🟡 图片 ${fileName} 已存在且内容一致，跳过`);
+      return { success: true, reason: "no_change" };
+    }
+    console.log(`[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)"
+      }
+    });
+    if (!imageResponse.ok) {
+      throw new Error(`图片下载失败，HTTP状态码: ${imageResponse.status}`);
+    }
+    const imageBuffer = Buffer.from(await imageResponse.arrayBuffer());
+    console.log(
+      `[SyncImg] 📤 上传图片: ${fileName} (大小: ${(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("text", CONFIG.UPLOAD_TEXT);
+    form.append("comment", CONFIG.UPLOAD_COMMENT);
+    form.append("token", token);
+    form.append("ignorewarnings", "1");
+    form.append("format", "json");
+    form.append("file", imageBuffer, {
+      filename: fileName.split(":").pop() || fileName,
+      contentType: imageResponse.headers.get("content-type") || "application/octet-stream"
+    });
+    const rawResponse = await targetBot.rawRequest({
+      method: "POST",
+      url: targetBot.options.apiUrl,
+      data: form,
+      headers: {
+        ...form.getHeaders(),
+        "X-authkey": `${getSitesConfig(config).huiji.uakey}`
+      }
+    });
+    const responseData = rawResponse.data;
+    if (responseData.upload && responseData.upload.result === "Success") {
+      console.log(`[SyncImg] ✅ 图片 ${fileName} 同步成功`);
+      return { success: true, reason: "synced" };
+    } else if (responseData.error) {
+      throw new Error(`${responseData.error.code}: ${responseData.error.info}`);
+    } else {
+      throw new Error(`未知响应: ${JSON.stringify(responseData)}`);
+    }
+  } catch (error) {
+    const errMsg = error.message || String(error);
+    console.error(`[SyncImg] ❌ 图片 ${fileName} 同步失败:`, errMsg);
+    return { success: false, reason: errMsg };
+  }
+}
+__name(syncSingleImage, "syncSingleImage");
+async function getAllImages(site) {
+  console.log(`[SyncAllImg] 📥 开始获取WikiGG所有图片`);
+  const allImages = [];
+  const queryGen = site.continuedQueryGen({
+    action: "query",
+    list: "allimages",
+    ailimit: "max",
+    aidir: "ascending",
+    ainamespace: 6
+  });
+  for await (const res of queryGen) {
+    const imageItems = res.query?.allimages || [];
+    const imageTitles = imageItems.map((img) => img.title);
+    allImages.push(...imageTitles);
+    console.log(`[SyncAllImg] 📄 已获取 ${allImages.length} 个图片`);
+  }
+  console.log(`[SyncAllImg] 📊 总计获取到 ${allImages.length} 个图片`);
+  return allImages;
+}
+__name(getAllImages, "getAllImages");
+async function syncAllImages(sourceBot, targetBot, config) {
+  try {
+    const imageList = await getAllImages(sourceBot);
+    if (imageList.length === 0) {
+      console.log(`[SyncAllImg] 📭 源站无图片可同步，结束`);
+      return;
+    }
+    let successCount = 0;
+    let failCount = 0;
+    let skipCount = 0;
+    const failedImages = [];
+    console.log(
+      `[SyncAllImg] 🚦 开始批量同步，总计 ${imageList.length} 个图片`
+    );
+    for (let i = 0; i < imageList.length; i++) {
+      const fileName = imageList[i];
+      const progress = (i + 1) / imageList.length * 100;
+      console.log(
+        `
+[SyncAllImg] 📈 进度 ${i + 1}/${imageList.length} (${progress.toFixed(1)}%)`
+      );
+      const result = await syncSingleImage(
+        sourceBot,
+        targetBot,
+        fileName,
+        config
+      );
+      if (!result.success) {
+        failCount++;
+        failedImages.push(fileName);
+        await (0, import_koishi.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);
+      }
+    }
+    if (failedImages.length > 0) {
+      console.log(
+        `
+[SyncAllImg] 🔄 开始重试 ${failedImages.length} 个失败图片`
+      );
+      const stillFailed = [];
+      for (const fileName of failedImages) {
+        console.log(`
+[SyncAllImg] 🔁 重试: ${fileName}`);
+        const result = await syncSingleImage(
+          sourceBot,
+          targetBot,
+          fileName,
+          config
+        );
+        if (result.success) {
+          successCount++;
+          failCount--;
+          console.log(`[SyncAllImg] ✅ 重试成功: ${fileName}`);
+        } else {
+          stillFailed.push(fileName);
+          console.log(`[SyncAllImg] ❌ 重试失败: ${fileName}`);
+        }
+        await (0, import_koishi.sleep)(CONFIG.SYNC_INTERVAL_SUCCESS);
+      }
+      if (stillFailed.length > 0) {
+        console.log(`
+[SyncAllImg] ❌ 最终失败列表（需手动处理）:`);
+        stillFailed.forEach(
+          (title, idx) => console.log(`  ${idx + 1}. ${title}`)
+        );
+      } else {
+        console.log(`
+[SyncAllImg] 🎉 所有失败图片重试成功！`);
+      }
+    }
+    console.log(`
+[SyncAllImg] 📊 同步完成！`);
+    console.log(`├─ 总计：${imageList.length} 个图片`);
+    console.log(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
+    console.log(`└─ 失败：${failCount} 个`);
+  } catch (globalError) {
+    console.error(`[SyncAllImg] 💥 同步流程异常终止:`, globalError);
+    throw globalError;
+  }
+}
+__name(syncAllImages, "syncAllImages");
+
+// src/sync/pageSync.ts
+var CONFIG2 = {
+  IGNORED_PAGES: /* @__PURE__ */ new Set(["教程", "MediaWiki:Common.css"]),
+  SYNC_INTERVAL_SUCCESS: 500,
+  SYNC_INTERVAL_FAILED: 1e3,
+  NAMESPACE: 0,
+  BATCH_LIMIT: "max",
+  FILE_NAMESPACE_PREFIX: "File:",
+  DEFAULT_USER: "同步坤器人",
+  INCREMENTAL_USER: "定时同步"
+};
+async function syncSinglePage(oldSite, newSite, pageTitle, user) {
+  if (CONFIG2.IGNORED_PAGES.has(pageTitle)) {
+    console.log(`[syncSinglePage] 🚫 页面 ${pageTitle} 在忽略列表中，跳过`);
+    return { success: true, reason: "ignored" };
+  }
+  try {
+    console.log(`[syncSinglePage] 🚀 开始同步页面: ${pageTitle}`);
+    const [oldContent, newContent] = await Promise.all([
+      getAndProcessPageContent(oldSite, pageTitle),
+      getAndProcessPageContent(newSite, pageTitle)
+    ]);
+    if (oldContent === newContent) {
+      console.log(`[syncSinglePage] 🟡 页面 ${pageTitle} 内容未改变，跳过`);
+      return { success: true, reason: "no_change" };
+    }
+    await newSite.save(pageTitle, oldContent, `由：${user} 触发更改，此时同步`);
+    console.log(`[syncSinglePage] ✅ 页面 ${pageTitle} 同步成功`);
+    return { success: true, reason: "synced" };
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[syncSinglePage] ❌ 页面 ${pageTitle} 同步失败:`, errMsg);
+    return { success: false, reason: errMsg };
+  }
+}
+__name(syncSinglePage, "syncSinglePage");
+async function getAllPages(site) {
+  console.log(
+    `[SyncAllPages] 📥 开始获取原站点所有页面（命名空间${CONFIG2.NAMESPACE}）`
+  );
+  const allPages = [];
+  const queryGen = site.continuedQueryGen({
+    action: "query",
+    list: "allpages",
+    apnamespace: CONFIG2.NAMESPACE,
+    aplimit: CONFIG2.BATCH_LIMIT,
+    apdir: "ascending"
+  });
+  for await (const res of queryGen) {
+    const pageTitles = res.query?.allpages?.map((page) => page.title) || [];
+    allPages.push(...pageTitles);
+    console.log(`[SyncAllPages] 📄 已获取 ${allPages.length} 个页面`);
+  }
+  console.log(`[SyncAllPages] 📊 原站点总计获取到 ${allPages.length} 个页面`);
+  return allPages;
+}
+__name(getAllPages, "getAllPages");
+async function processPageWithStats(oldSite, newSite, pageTitle, user, stats, failedPages) {
+  const syncResult = await syncSinglePage(oldSite, newSite, pageTitle, user);
+  if (!syncResult.success) {
+    stats.failCount++;
+    failedPages.push(pageTitle);
+    await (0, import_koishi2.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);
+  }
+}
+__name(processPageWithStats, "processPageWithStats");
+function printProgress(current, total, pageTitle) {
+  const progress = (current / total * 100).toFixed(1);
+  const remaining = total - current;
+  console.log(
+    `
+[SyncAllPages] 📈 进度 [${current}/${total}] (${progress}%) - 处理 ${pageTitle} | 剩余 ${remaining} 个`
+  );
+}
+__name(printProgress, "printProgress");
+function printFinalReport(total, successCount, failCount, skipCount, stillFailed) {
+  console.log(`
+[SyncAllPages] 📋 ===== 最终同步报告 =====`);
+  if (stillFailed.length > 0) {
+    console.log(`❌ 以下页面经过重试仍然失败，请手动检查：`);
+    stillFailed.forEach((title, idx) => {
+      console.log(`  ${idx + 1}. ${title}`);
+    });
+  } else {
+    console.log(`🎉 所有页面同步成功（含重试）！`);
+  }
+  console.log(`
+[SyncAllPages] 🎯 同步流程结束！`);
+  console.log(`├─ 总计：${total} 个页面`);
+  console.log(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
+  console.log(`└─ 失败：${failCount} 个`);
+}
+__name(printFinalReport, "printFinalReport");
+async function syncPages(oldSite, newSite) {
+  try {
+    const oldPageList = await getAllPages(oldSite);
+    const total = oldPageList.length;
+    if (total === 0) {
+      console.log(`[SyncAllPages] 📭 原站点无页面可同步，结束`);
+      return;
+    }
+    const stats = { successCount: 0, failCount: 0, skipCount: 0 };
+    const failedPages = [];
+    console.log(`[SyncAllPages] 🚦 开始批量同步，总计 ${total} 个页面`);
+    for (let index = 0; index < total; index++) {
+      const pageTitle = oldPageList[index];
+      printProgress(index + 1, total, pageTitle);
+      await processPageWithStats(
+        oldSite,
+        newSite,
+        pageTitle,
+        CONFIG2.DEFAULT_USER,
+        stats,
+        failedPages
+      );
+    }
+    let stillFailed = [];
+    if (failedPages.length > 0) {
+      console.log(
+        `
+[SyncAllPages] 🔄 ===== 开始重试 ${failedPages.length} 个失败页面 =====`
+      );
+      for (const pageTitle of failedPages) {
+        console.log(`
+[SyncAllPages] 🔁 重试中: ${pageTitle}`);
+        const syncResult = await syncSinglePage(
+          oldSite,
+          newSite,
+          pageTitle,
+          CONFIG2.DEFAULT_USER
+        );
+        if (syncResult.success) {
+          stats.successCount++;
+          stats.failCount--;
+          if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
+            stats.skipCount++;
+          }
+          console.log(`[SyncAllPages] ✅ 页面 ${pageTitle} 重试成功`);
+          await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_SUCCESS);
+        } else {
+          stillFailed.push(pageTitle);
+          console.log(`[SyncAllPages] ❌ 页面 ${pageTitle} 再次失败`);
+          await (0, import_koishi2.sleep)(CONFIG2.SYNC_INTERVAL_FAILED);
+        }
+      }
+    }
+    printFinalReport(
+      total,
+      stats.successCount,
+      stats.failCount,
+      stats.skipCount,
+      stillFailed
+    );
+  } catch (globalError) {
+    console.error(`[SyncAllPages] 💥 批量同步流程异常终止:`, globalError);
+    throw globalError;
+  }
+}
+__name(syncPages, "syncPages");
+async function incrementalUpdate(oldSite, newSite, config) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const threeHoursAgo = new Date(now.getTime() - 3 * 60 * 60 * 1e3);
+    console.log(
+      `[增量更新流程] ⏰ 开始处理 ${threeHoursAgo.toISOString()} 到 ${now.toISOString()} 的更新...`
+    );
+    const queryGen = oldSite.continuedQueryGen({
+      action: "query",
+      list: "recentchanges",
+      rcstart: now.toISOString(),
+      rcend: threeHoursAgo.toISOString(),
+      rcdir: "older",
+      rcprop: "user|comment|title|timestamp"
+    });
+    const processedTitles = /* @__PURE__ */ new Set();
+    let totalProcessed = 0;
+    let totalSkipped = 0;
+    for await (const res of queryGen) {
+      const pages = res.query?.recentchanges || [];
+      for (const page of pages) {
+        const title = page.title;
+        if (processedTitles.has(title)) {
+          console.log(`[增量更新流程] ⏭️  已经处理过 ${title}, 跳过`);
+          totalSkipped++;
+          continue;
+        }
+        if (CONFIG2.IGNORED_PAGES.has(title)) {
+          console.log(
+            `[增量更新流程] 🚫 ${title} 在无需处理的页面列表中, 跳过`
+          );
+          processedTitles.add(title);
+          totalSkipped++;
+          continue;
+        }
+        processedTitles.add(title);
+        totalProcessed++;
+        try {
+          if (title.startsWith(CONFIG2.FILE_NAMESPACE_PREFIX)) {
+            const fileName = title.replace(CONFIG2.FILE_NAMESPACE_PREFIX, "");
+            console.log(
+              `[增量更新流程] 🖼️  检查到图片: ${title}，正在尝试转存`
+            );
+            await syncSingleImage(oldSite, newSite, fileName, config);
+          } else {
+            await syncSinglePage(
+              oldSite,
+              newSite,
+              title,
+              CONFIG2.INCREMENTAL_USER
+            );
+          }
+          await (0, import_koishi2.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);
+        }
+      }
+    }
+    console.log(
+      `[增量更新流程] ✅ 增量更新完成！处理: ${totalProcessed}, 跳过: ${totalSkipped}`
+    );
+  } catch (globalError) {
+    console.error(`[增量更新流程] 💥 增量更新流程异常终止:`, globalError);
+    throw globalError;
+  }
+}
+__name(incrementalUpdate, "incrementalUpdate");
+
+// src/sync/moduleSync.ts
+var import_koishi3 = require("koishi");
+var CONFIG3 = {
+  MODLE_NAMESPACE: 828,
+  // 模块命名空间 (注意：这里原代码拼写为 MODLE，保留原样)
+  IGNORED_MODULES: [],
+  // 忽略的模块列表
+  SYNC_INTERVAL_SUCCESS: 500,
+  // 同步成功后等待时间（毫秒）
+  SYNC_INTERVAL_FAILED: 1e3
+  // 同步失败后等待时间（毫秒）
+};
+async function syncSingleModule(oldSite, newSite, moduleTitle, user) {
+  if (CONFIG3.IGNORED_MODULES.includes(moduleTitle)) {
+    console.log(`[SyncModule] 🚫 模块 ${moduleTitle} 在忽略列表中，跳过`);
+    return { success: true, reason: "ignored" };
+  }
+  try {
+    console.log(`[SyncModule] 🔍 开始获取模块 ${moduleTitle} 的内容`);
+    const [oldContent, newContent] = await Promise.all([
+      getAndProcessPageContent(oldSite, moduleTitle),
+      getAndProcessPageContent(newSite, moduleTitle)
+    ]);
+    if (oldContent === newContent) {
+      console.log(`[SyncModule] 🟡 模块 ${moduleTitle} 内容未改变，跳过`);
+      return { success: true, reason: "no_change" };
+    }
+    await newSite.save(
+      moduleTitle,
+      oldContent,
+      `由：${user || "同步坤器人手动"} 触发更改，此时同步`
+    );
+    console.log(`[SyncModule] ✅ 模块 ${moduleTitle} 同步成功`);
+    return { success: true, reason: "synced" };
+  } catch (error) {
+    const errMsg = error.message || String(error);
+    console.error(`[SyncModule] ❌ 模块 ${moduleTitle} 同步失败:`, errMsg);
+    return { success: false, reason: errMsg };
+  }
+}
+__name(syncSingleModule, "syncSingleModule");
+async function getAllModules(site) {
+  console.log(
+    `[SyncAllModules] 📥 开始获取原站点所有模块（命名空间${CONFIG3.MODLE_NAMESPACE}）`
+  );
+  const allModules = [];
+  const queryGen = site.continuedQueryGen({
+    action: "query",
+    list: "allpages",
+    apnamespace: CONFIG3.MODLE_NAMESPACE,
+    // 模块命名空间
+    aplimit: "max",
+    apdir: "ascending"
+  });
+  for await (const res of queryGen) {
+    const moduleTitles = res.query?.allpages?.map((page) => page.title) || [];
+    allModules.push(...moduleTitles);
+    console.log(`[SyncAllModules] 📄 已获取 ${allModules.length} 个模块`);
+  }
+  console.log(
+    `[SyncAllModules] 📊 原站点总计获取到 ${allModules.length} 个模块`
+  );
+  return allModules;
+}
+__name(getAllModules, "getAllModules");
+async function syncModules(oldSite, newSite) {
+  try {
+    const oldModuleList = await getAllModules(oldSite);
+    const total = oldModuleList.length;
+    if (total === 0) {
+      console.log(`[SyncAllModules] 📭 原站点无模块可同步，结束`);
+      return;
+    }
+    let successCount = 0;
+    let failCount = 0;
+    let skipCount = 0;
+    const failedModules = [];
+    console.log(`[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(
+        `
+[SyncAllModules] 📈 进度 [${current}/${total}] (${progress}%) - 处理 ${moduleTitle} | 剩余 ${remaining} 个`
+      );
+      const syncResult = await syncSingleModule(
+        oldSite,
+        newSite,
+        moduleTitle,
+        "同步坤器人"
+      );
+      if (!syncResult.success) {
+        failCount++;
+        failedModules.push(moduleTitle);
+        await (0, import_koishi3.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);
+      }
+    }
+    if (failedModules.length > 0) {
+      console.log(
+        `
+[SyncAllModules] 🔄 ===== 开始重试 ${failedModules.length} 个失败模块 =====`
+      );
+      const stillFailed = [];
+      for (const moduleTitle of failedModules) {
+        console.log(`
+[SyncAllModules] 🔁 重试中: ${moduleTitle}`);
+        const syncResult = await syncSingleModule(
+          oldSite,
+          newSite,
+          moduleTitle,
+          "同步坤器人"
+        );
+        if (syncResult.success) {
+          successCount++;
+          failCount--;
+          if (syncResult.reason === "ignored" || syncResult.reason === "no_change") {
+            skipCount++;
+          }
+          console.log(`[SyncAllModules] ✅ 模块 ${moduleTitle} 重试成功`);
+          await (0, import_koishi3.sleep)(CONFIG3.SYNC_INTERVAL_SUCCESS);
+        } else {
+          stillFailed.push(moduleTitle);
+          console.log(`[SyncAllModules] ❌ 模块 ${moduleTitle} 再次失败`);
+          await (0, import_koishi3.sleep)(CONFIG3.SYNC_INTERVAL_FAILED);
+        }
+      }
+      console.log(`
+[SyncAllModules] 📋 ===== 最终同步报告 =====`);
+      if (stillFailed.length > 0) {
+        console.log(`❌ 以下模块经过重试仍然失败，请手动检查：`);
+        stillFailed.forEach((title, idx) => {
+          console.log(`  ${idx + 1}. ${title}`);
+        });
+      } else {
+        console.log(`🎉 所有模块同步成功（含重试）！`);
+      }
+    }
+    console.log(`
+[SyncAllModules] 🎯 同步完成！`);
+    console.log(`├─ 总计：${total} 个模块`);
+    console.log(`├─ 成功：${successCount} 个（含跳过 ${skipCount} 个）`);
+    console.log(`└─ 失败：${failCount} 个`);
+  } catch (error) {
+    console.error(`[SyncAllModules] 💥 批量同步流程异常终止:`, error);
+    throw error;
+  }
+}
+__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")
+});
+function apply(ctx, config) {
+  const logger = ctx.logger("oni-sync-bot");
+  let ggbot;
+  let huijibot;
+  ctx.inject(["console"], (ctx2) => {
+    ctx2.console.addEntry({
+      dev: (0, import_path.resolve)(__dirname, "../client/index.ts"),
+      prod: (0, import_path.resolve)(__dirname, "../dist")
+    });
+  });
+  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.mirror_site}/${encodeURIComponent(
+      page.title
+    )}`;
+    router.redirect(targetUrl);
+  });
+  ctx.on("ready", async () => {
+    logger.info("初始化中...");
+    const sitesConfig = getSitesConfig(config);
+    ggbot = await login(sitesConfig.gg);
+    huijibot = await login(sitesConfig.huiji);
+    if (ggbot.login && huijibot.login) {
+      logger.info("登录成功，插件已准备就绪");
+    } else {
+      logger.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");
+      }).catch((err) => {
+        logger.error(`同步所有页面失败，错误信息：${err}`);
+      });
+    });
+    ctx.cron("30 8 * * 3", async () => {
+      await syncAllImages(ggbot, huijibot, config).then(() => {
+        logger.info("自动任务：尝试同步所有图片，从 WIKIGG 到 灰机wiki");
+      }).catch((err) => {
+        logger.error(`同步所有图片失败，错误信息：${err}`);
+      });
+    });
+  });
+  ctx.command("sync <pageTitle:string>", "同步指定页面", { authority: 2 }).action(async ({ session }, pageTitle) => {
+    await syncSinglePage(ggbot, huijibot, pageTitle, "sync-bot").then(() => {
+      session.send(
+        `✅ 已尝试同步页面：${pageTitle}，从 WIKIGG 到 灰机wiki`
+      );
+    }).catch((err) => {
+      session.send(`❌ 同步页面失败：${pageTitle}，错误信息：${err}`);
+    });
+  });
+  ctx.command("sync.incrementalUpdate", "同步所有页面", { authority: 2 }).alias("增量更新").action(async ({ session }) => {
+    session.send(`🚀 开始同步所有页面，任务耗时可能较长，请耐心等待...`);
+    await incrementalUpdate(ggbot, huijibot, config).then(() => {
+      session.send(
+        `✅ 已尝试获取三小时前的编辑并同步，从 WIKIGG 到 灰机wiki`
+      );
+    }).catch((err) => {
+      session.send(`❌ 同步所有页面失败，错误信息：${err}`);
+    });
+  });
+  ctx.command("sync.allpages", "同步所有页面", { authority: 2 }).action(async ({ session }) => {
+    session.send(`🚀 开始同步所有页面，任务耗时较长，请耐心等待...`);
+    await syncPages(ggbot, huijibot).then(() => {
+      session.send(`✅ 已尝试同步所有页面，从 WIKIGG 到 灰机wiki`);
+    }).catch((err) => {
+      session.send(`❌ 同步所有页面失败，错误信息：${err}`);
+    });
+  });
+  ctx.command("sync.module <moduleTitle:string>", "同步指定模块", {
+    authority: 2
+  }).action(async ({ session }, moduleTitle) => {
+    await syncSingleModule(ggbot, huijibot, moduleTitle, "sync-bot").then(() => {
+      session.send(
+        `✅ 已尝试同步模块：${moduleTitle}，从 WIKIGG 到 灰机wiki`
+      );
+    }).catch((err) => {
+      session.send(`❌ 同步模块失败：${moduleTitle}，错误信息：${err}`);
+    });
+  });
+  ctx.command("sync.allmodules", "同步所有模块", { authority: 2 }).action(async ({ session }) => {
+    session.send(`🚀 开始同步所有模块，任务耗时较长，请耐心等待...`);
+    await syncModules(ggbot, huijibot).then(() => {
+      session.send(`✅ 已尝试同步所有模块，从 WIKIGG 到 灰机wiki`);
+    }).catch((err) => {
+      session.send(`❌ 同步所有模块失败，错误信息：${err}`);
+    });
+  });
+  ctx.command("sync.img <imgTitle:string>", "同步指定图片", { authority: 2 }).action(async ({ session }, imgTitle) => {
+    await syncSingleImage(
+      ggbot,
+      huijibot,
+      `${imgTitle.startsWith("File:") ? "" : "File:"}${imgTitle}`,
+      config
+    ).then(() => {
+      session.send(`✅ 已尝试同步图片：${imgTitle}`);
+    }).catch((err) => {
+      session.send(`❌ 同步图片失败：${imgTitle}，错误信息：${err}`);
+    });
+  });
+  ctx.command("sync.allimgs", "同步所有图片", { authority: 2 }).action(async ({ session }) => {
+    session.send(`🚀 开始同步所有图片，任务耗时较长，请耐心等待...`);
+    await syncAllImages(ggbot, huijibot, config).then(() => {
+      session.send(`✅ 已尝试同步所有图片，从 WIKIGG 到 灰机wiki`);
+    }).catch((err) => {
+      session.send(`❌ 同步所有图片失败，错误信息：${err}`);
+    });
+  });
+  ctx.command("x <itemName>", "查询缺氧中文wiki，精准匹配+拼音模糊匹配").alias("/查wiki").action(async ({ session }, itemName = "") => {
+    const queryKey = itemName.trim().toLowerCase();
+    if (queryKey === "")
+      return `以下是使用说明：
+原站点: https://${config.domain}/gg/88888888
+
+镜像站: https://${config.domain}/bw/88888888`;
+    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}
+
+镜像站: https://${config.domain}/bw/${id2}`;
+    }
+    const preciseFullPinyinRes = await ctx.database.get("wikipages", {
+      pinyin_full: queryKey
+    });
+    if (preciseFullPinyinRes.length > 0) {
+      const { id: id2, title } = preciseFullPinyinRes[0];
+      return `✅ 拼音精准匹配成功（${queryKey} → ${title}）
+原站点: https://${config.domain}/gg/${id2}
+
+镜像站: https://${config.domain}/bw/${id2}`;
+    }
+    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}
+
+镜像站: https://${config.domain}/bw/${id2}`;
+    }
+    const allPages = await ctx.database.get("wikipages", {});
+    if (allPages.length === 0) {
+      return `❌ 本地缓存为空，请联系管理员执行【update】指令更新缓存！`;
+    }
+    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;
+      if (score > 0) {
+        matchResult.push({ id: page.id, 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()
+    ).slice(0, 5);
+    const resultCount = uniqueResult.length;
+    let replyMsg = `🔍 未找到精准匹配，为你找到【 ${resultCount} 】个相似结果，请输入序号选择（10秒内有效）：
+`;
+    uniqueResult.forEach((item, index) => {
+      replyMsg += `${index + 1}. ${item.title}
+`;
+    });
+    replyMsg += `
+❗️ 提示：超时将静默结束，无任何回应`;
+    await session.send(replyMsg);
+    const userInput = await session.prompt(15e3);
+    if (!userInput) return;
+    const selectNum = parseInt(userInput.trim());
+    if (isNaN(selectNum) || selectNum < 1 || selectNum > resultCount) {
+      return `❌ 输入无效！请输入 1-${resultCount} 之间的数字序号`;
+    }
+    const { id } = uniqueResult[selectNum - 1];
+    return `✅ 选择成功
+原站点: https://${config.domain}/gg/${id}
+
+镜像站: https://${config.domain}/bw/${id}`;
+  });
+  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);
+      }
+      session.send(`✅ 检索到 ${pages.length} 个页面，已更新至数据库`);
+      logger.info(`检索到 ${pages.length} 个页面，已更新至数据库`);
+    } catch (err) {
+      logger.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) {
+      logger.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) {
+      logger.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) {
+      logger.error(`添加重定向 ${pageName} -> ${targetPageName} 失败`, err);
+      session.send(`❌ 添加重定向失败，请联系管理员查看日志`);
+    }
+  });
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Config,
+  apply,
+  inject,
+  name
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-oni-sync-bot",
   "description": "缺氧Wiki站镜像点同步-测试",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -23,6 +23,7 @@
   },
   "dependencies": {
     "@types/node-fetch": "^2.6.13",
+    "form-data": "^4.0.5",
     "koishi-plugin-cron": "^3.1.0",
     "mwn": "^3.0.1",
     "node-fetch": "^3.3.2",