NSDF 助手

Greasy Fork is available in English.
DeepFlood & NodeSeek 论坛增强脚本（基于 NSaide 改造）
当前为 2025-10-16 提交的版本，查看最新版本。
换行
// ==UserScript==
// @name         NSDF 助手
// @namespace    https://www.deepflood.com/
// @version      0.2.2
// @description  DeepFlood & NodeSeek 论坛增强脚本（基于 NSaide 改造）
// @author       zen1zi
// @license      GPL-3.0
// @match        https://www.deepflood.com/*
// @match        https://deepflood.com/*
// @match        https://www.nodeseek.com/*
// @match        https://nodeseek.com/*
// @icon         https://www.deepflood.com/favicon.ico
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_deleteValue
// @grant        GM_xmlhttpRequest
// @grant        GM_registerMenuCommand
// @grant        GM_unregisterMenuCommand
// @grant        GM_listValues
// @grant        GM_info
// @grant        unsafeWindow
// @run-at       document-start
// ==/UserScript==
(function () {
  "use strict";

  console.log("[DF助手] 脚本开始加载");

  const HOST_SITE_MAP = {
    "www.deepflood.com": { id: "deepflood", name: "DeepFlood" },
    "deepflood.com": { id: "deepflood", name: "DeepFlood" },
    "www.nodeseek.com": { id: "nodeseek", name: "NodeSeek" },
    "nodeseek.com": { id: "nodeseek", name: "NodeSeek" },
  };

  const currentHost = window.location.host;
  const siteMeta = HOST_SITE_MAP[currentHost] || {
    id: "unknown",
    name: currentHost,
  };
  const siteInfo = Object.freeze({
    ...siteMeta,
    host: currentHost,
    origin: window.location.origin,
    isDeepFlood: siteMeta.id === "deepflood",
    isNodeSeek: siteMeta.id === "nodeseek",
  });

  if (siteInfo.id === "unknown") {
    console.warn("[DF助手] 检测到未配置站点，尝试按当前域名加载");
  } else {
    console.log(`[DF助手] 当前站点: ${siteInfo.name} (${siteInfo.host})`);
  }

  const CONFIG_URL =
    "https://raw.githubusercontent.com/zen1zi/NSDF_Plus/main/modules/config.json";
  const CACHE_EXPIRY = 30 * 60 * 1000;
  const CACHE_KEY_PREFIX = "df_module_cache_";
  const CONFIG_CACHE_KEY = "df_config_cache";
  const MODULE_ENABLED_KEY_PREFIX = "df_MODULE_ENABLED_";
  const LEGACY_MODULE_ENABLED_KEY_PREFIX = "module_";
  const LEGACY_MODULE_ENABLED_KEY_SUFFIX = "_enabled";

  const normalizeModuleIdForKey = (id) => {
    if (typeof id !== "string") {
      return "";
    }

    return id
      .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
      .replace(/[^a-z0-9]/gi, "_")
      .toUpperCase();
  };

  const getCachedData = (key) => {
    const cached = GM_getValue(key);
    if (typeof cached !== "string" || cached.length === 0) {
      console.log(`[DF助手] 缓存未命中: ${key}`);
      return null;
    }

    try {
      const { data, timestamp } = JSON.parse(cached);
      const age = Date.now() - timestamp;
      if (age > CACHE_EXPIRY) {
        console.log(
          `[DF助手] 缓存已过期: ${key} (${Math.round(age / 1000)}s 前)`,
        );
        deleteCachedData(key, { silent: true });
        return null;
      }
      console.log(`[DF助手] 缓存命中: ${key} (${Math.round(age / 1000)}s 前)`);
      return data;
    } catch (error) {
      console.warn(`[DF助手] 缓存数据解析失败: ${key}`, error);
      deleteCachedData(key, { silent: true });
      return null;
    }
  };

  const setCachedData = (key, data) => {
    try {
      GM_setValue(
        key,
        JSON.stringify({
          data,
          timestamp: Date.now(),
        }),
      );
      console.log(`[DF助手] 缓存已保存: ${key}`);
    } catch (error) {
      console.error(`[DF助手] 缓存保存失败: ${key}`, error);
    }
  };

  const deleteCachedData = (key, { silent = false } = {}) => {
    try {
      GM_deleteValue(key);
      if (!silent) {
        console.log(`[DF助手] 缓存已清理: ${key}`);
      }
    } catch (error) {
      console.error(`[DF助手] 缓存清理失败: ${key}`, error);
    }
  };

  const fetchWithCache = (url, cacheKey, retryCount = 3) => {
    return new Promise((resolve, reject) => {
      const cached = getCachedData(cacheKey);
      if (cached) {
        resolve(cached);
        return;
      }

      console.log(`[DF助手] 开始远程获取: ${url}`);

      const attemptFetch = (attempt) => {
        GM_xmlhttpRequest({
          method: "GET",
          url: `${url}?t=${Date.now()}`,
          timeout: 10000,
          nocache: true,
          headers: {
            "Cache-Control": "no-cache",
            Pragma: "no-cache",
          },
          onload: (response) => {
            if (response.status === 200) {
              try {
                const data = response.responseText;
                setCachedData(cacheKey, data);
                console.log(`[DF助手] 远程获取成功: ${url}`);
                resolve(data);
              } catch (error) {
                console.error(`[DF助手] 数据处理失败: ${url}`, error);
                reject(error);
              }
            } else {
              const error = new Error(
                `HTTP ${response.status}: ${response.statusText}`,
              );
              if (attempt < retryCount) {
                console.warn(
                  `[DF助手] 请求失败，重试 ${attempt}/${retryCount}: ${url}`,
                  error.message,
                );
                setTimeout(() => attemptFetch(attempt + 1), 1000 * attempt);
              } else {
                console.error(`[DF助手] 请求最终失败: ${url}`, error);
                reject(error);
              }
            }
          },
          onerror: (error) => {
            if (attempt < retryCount) {
              console.warn(
                `[DF助手] 网络错误，重试 ${attempt}/${retryCount}: ${url}`,
                error,
              );
              setTimeout(() => attemptFetch(attempt + 1), 1000 * attempt);
            } else {
              console.error(`[DF助手] 网络错误最终失败: ${url}`, error);
              reject(error);
            }
          },
          ontimeout: () => {
            const error = new Error("请求超时");
            if (attempt < retryCount) {
              console.warn(
                `[DF助手] 请求超时，重试 ${attempt}/${retryCount}: ${url}`,
              );
              setTimeout(() => attemptFetch(attempt + 1), 1000 * attempt);
            } else {
              console.error(`[DF助手] 请求超时最终失败: ${url}`);
              reject(error);
            }
          },
        });
      };

      attemptFetch(1);
    });
  };

  const loadConfig = async () => {
    try {
      const configText = await fetchWithCache(CONFIG_URL, CONFIG_CACHE_KEY);
      return JSON.parse(configText);
    } catch (error) {
      console.error("[DF助手] 配置加载失败:", error);
      throw error;
    }
  };

  const loadModule = async (moduleInfo) => {
    const cacheKey = `${CACHE_KEY_PREFIX}${moduleInfo.id}`;
    const loadStartTime = Date.now();

    try {
      console.log(`[DF助手] 开始加载模块: ${moduleInfo.name}`);
      const moduleCode = await fetchWithCache(moduleInfo.url, cacheKey);

      // 检查模块代码安全性 - 简单的恶意代码检测
      if (
        moduleCode.includes("eval(") &&
        !moduleCode.includes("// Safe eval")
      ) {
        console.warn(`[DF助手] 模块 ${moduleInfo.name} 包含可疑代码，跳过加载`);
        return;
      }

      eval(moduleCode);
      const loadTime = Date.now() - loadStartTime;
      console.log(`[DF助手] 模块加载成功: ${moduleInfo.name} (${loadTime}ms)`);

      // 记录模块加载性能
      window.DF.dev.moduleLoadTimes = window.DF.dev.moduleLoadTimes || {};
      window.DF.dev.moduleLoadTimes[moduleInfo.id] = loadTime;
    } catch (error) {
      console.error(`[DF助手] 模块 ${moduleInfo.name} 加载失败:`, error);

      // 尝试从缓存中清除损坏的模块
      deleteCachedData(cacheKey, { silent: true });
      console.log(`[DF助手] 已清理损坏的模块缓存: ${moduleInfo.id}`);

      throw error;
    }
  };

  const createDF = () => {
    window.DF = {
      version: GM_info.script.version,
      modules: new Map(),
      isReady: false,
      site: siteInfo,

      registerModule(moduleDefinition) {
        if (!moduleDefinition || !moduleDefinition.id || !moduleDefinition.init)
          return;

        const normalizedId = normalizeModuleIdForKey(moduleDefinition.id);
        const enabledKey = `${MODULE_ENABLED_KEY_PREFIX}${normalizedId}`;
        let enabled = GM_getValue(enabledKey);

        if (typeof enabled === "undefined") {
          const legacyKey = `${LEGACY_MODULE_ENABLED_KEY_PREFIX}${moduleDefinition.id}${LEGACY_MODULE_ENABLED_KEY_SUFFIX}`;
          const legacyValue = GM_getValue(legacyKey);

          if (typeof legacyValue !== "undefined") {
            enabled = legacyValue;
            try {
              GM_setValue(enabledKey, legacyValue);
              GM_deleteValue(legacyKey);
              console.log(
                `[DF助手] 已迁移模块启用状态: ${moduleDefinition.id}`,
              );
            } catch (migrationError) {
              console.warn(
                `[DF助手] 模块启用状态迁移失败: ${moduleDefinition.id}`,
                migrationError,
              );
            }
          } else {
            enabled = true;
            try {
              GM_setValue(enabledKey, enabled);
            } catch (error) {
              console.warn(
                `[DF助手] 默认写入模块启用状态失败: ${moduleDefinition.id}`,
                error,
              );
            }
          }
        }

        if (typeof enabled === "string") {
          enabled = enabled.toLowerCase() === "true";
        } else {
          enabled = Boolean(enabled);
        }

        const module = {
          ...moduleDefinition,
          enabled: enabled,
          enabledStorageKey: enabledKey,
        };

        this.modules.set(moduleDefinition.id, module);
        console.log(`[DF助手] 模块已注册: ${module.name}`);
      },

      init() {
        if (this.isReady) return;

        const enabledModules = Array.from(this.modules.values()).filter(
          (m) => m.enabled,
        );
        console.log(
          `[DF助手] 开始初始化 ${enabledModules.length} 个已启用模块`,
        );

        Promise.all(
          enabledModules.map(
            (module) =>
              new Promise((resolve) => {
                try {
                  module.init();
                  console.log(`[DF助手] 模块初始化成功: ${module.name}`);
                  resolve();
                } catch (error) {
                  console.error(
                    `[DF助手] 模块 ${module.name} 初始化失败:`,
                    error,
                  );
                  resolve();
                }
              }),
          ),
        ).then(() => {
          this.isReady = true;
          console.log("[DF助手] 所有模块初始化完成");
        });
      },
    };

    window.DF.getSiteUrl = (path = "") => {
      if (typeof path !== "string" || path.length === 0) {
        return window.DF.site.origin;
      }

      if (/^https?:\/\//i.test(path)) {
        return path;
      }

      const normalizedPath = path.startsWith("/") ? path : `/${path}`;
      return `${window.DF.site.origin}${normalizedPath}`;
    };

    window.DFRegisterModule = (moduleDefinition) => {
      window.DF.registerModule(moduleDefinition);
    };

    // 缓存工具 - 可供模块使用
    window.DF.cache = {
      get: getCachedData,
      set: setCachedData,
      delete: deleteCachedData,
      fetch: fetchWithCache,
      expiry: CACHE_EXPIRY,
      keyPrefix: CACHE_KEY_PREFIX,
    };

    // 开发者工具
    window.DF.dev = {
      clearCache() {
        const removedKeys = [];

        try {
          const storedKeys = GM_listValues();
          storedKeys.forEach((key) => {
            if (key === CONFIG_CACHE_KEY || key.startsWith(CACHE_KEY_PREFIX)) {
              deleteCachedData(key, { silent: true });
              removedKeys.push(key);
            }
          });
        } catch (error) {
          console.error("[DF助手] 遍历缓存键失败:", error);
        }

        console.log(`[DF助手] 已清理缓存: ${removedKeys.length} 项`);
        return removedKeys;
      },
      getCacheInfo() {
        const info = {};
        let storedKeys = [];

        try {
          storedKeys = GM_listValues();
        } catch (error) {
          console.error("[DF助手] 获取缓存信息失败:", error);
        }

        const storedSet = new Set(storedKeys);
        info.config = storedSet.has(CONFIG_CACHE_KEY) ? "已缓存" : "未缓存";
        window.DF.modules.forEach((module, id) => {
          const moduleCacheKey = `${CACHE_KEY_PREFIX}${id}`;
          info[id] = storedSet.has(moduleCacheKey) ? "已缓存" : "未缓存";
        });
        return info;
      },
      getModuleHealth() {
        const health = {};
        window.DF.modules.forEach((module, id) => {
          health[id] = {
            id: module.id,
            name: module.name,
            enabled: module.enabled,
            loaded: !!module.init,
            cached: typeof GM_getValue(`${CACHE_KEY_PREFIX}${id}`) === "string",
          };
        });
        return health;
      },
    };
  };

  const initializeModules = async () => {
    const initStartTime = Date.now();

    try {
      console.log("[DF助手] 开始初始化模块系统");
      createDF();

      const config = await loadConfig();
      console.log(
        `[DF助手] 配置加载成功，发现 ${config.modules.length} 个模块`,
      );

      // 并行加载模块，但容错处理
      const moduleLoadPromises = config.modules.map(async (moduleInfo) => {
        try {
          await loadModule(moduleInfo);
          return { success: true, module: moduleInfo.id };
        } catch (error) {
          console.error(`[DF助手] 模块 ${moduleInfo.id} 加载失败:`, error);
          return { success: false, module: moduleInfo.id, error };
        }
      });

      const results = await Promise.all(moduleLoadPromises);
      const successful = results.filter((r) => r.success).length;
      const failed = results.filter((r) => !r.success);

      console.log(
        `[DF助手] 模块加载完成: ${successful}/${config.modules.length} 成功`,
      );

      if (failed.length > 0) {
        console.warn(
          "[DF助手] 加载失败的模块:",
          failed.map((f) => f.module),
        );
      }

      if (window.DF.modules.size > 0) {
        window.DF.init();
        const initTime = Date.now() - initStartTime;
        console.log(
          `[DF助手] 初始化完成 (${initTime}ms)，已加载 ${window.DF.modules.size} 个模块`,
        );

        // 注册菜单命令
        GM_registerMenuCommand("⚙️ 清理缓存", () => {
          window.DF.dev.clearCache();
          alert("缓存已清理，请刷新页面");
        });
      } else {
        console.warn("[DF助手] 没有模块成功加载");
      }
    } catch (error) {
      console.error("[DF助手] 初始化失败:", error);

      // 降级处理：尝试只加载设置模块
      try {
        console.log("[DF助手] 尝试降级启动...");
        const fallbackConfig = {
          modules: [
            {
              id: "settings",
              name: "设置面板",
              url: "https://raw.githubusercontent.com/zen1zi/NSDF_Plus/main/modules/settings/index.js",
            },
          ],
        };

        await loadModule(fallbackConfig.modules[0]);
        if (window.DF.modules.size > 0) {
          window.DF.init();
          console.log("[DF助手] 降级启动成功");
        }
      } catch (fallbackError) {
        console.error("[DF助手] 降级启动也失败:", fallbackError);
      }
    }
  };

  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", initializeModules);
  } else {
    initializeModules();
  }
})();