Greasy Fork is available in English.
DeepFlood & NodeSeek 论坛增强脚本（基于 NSaide 改造）
当前为
// ==UserScript==
// @name NSDF 助手
// @namespace https://www.deepflood.com/
// @version 0.2.0
// @description DeepFlood & NodeSeek 论坛增强脚本（基于 NSaide 改造）
// @author
// @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('DF助手 - 打开设置', () => {
const settingsModule = window.DF.modules.get('settings');
if (settingsModule && settingsModule.utils && settingsModule.utils.showSettingsPanel) {
settingsModule.utils.showSettingsPanel();
} else {
console.warn('[DF助手] 设置模块未加载或不可用');
}
});
GM_registerMenuCommand('DF助手 - 清理缓存', () => {
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();
}
})();