// ==UserScript== // @name [sumuve首发]光鸭秒传工具（修复迅雷秒传光鸭，光鸭提取json） // @namespace https://github.com/sumuve/guangya-rapid-transfer // @version 1.1.2 // @description 光鸭云盘网页端：导入秒传JSON、提取秒传JSON、搜索资源（迅雷/阿里/百度/夸克/磁力）；迅雷云盘页面：提取迅雷云盘秒传JSON、迅雷分享页提取JSON、秒传到光鸭云盘。作者：sumuve // @author sumuve // @icon https://www.guangyapan.com/icon.png // @license MIT // @run-at document-start // @match https://guangyapan.com/* // @match https://*.guangyapan.com/* // @match https://pan.xunlei.com/* // @grant GM_setClipboard // @grant GM_xmlhttpRequest // @grant GM_getValue // @grant GM_setValue // @grant GM_registerMenuCommand // @grant GM_unregisterMenuCommand // @grant GM_openInTab // @grant unsafeWindow // @connect api.guangyapan.com // @connect api-pan.xunlei.com // @connect so.252035.xyz // @connect * // @connect *.xunlei.com // @connect *.aliyuncs.com // @connect *.cdngc.net // @tag 光鸭云盘 // @tag 迅雷云盘 // @tag 秒传 // @tag 网盘 // @tag 资源搜索 // ==/UserScript== (function () { "use strict"; const SCRIPT_VERSION = "1.1.2"; const GUANGYA_API_BASE = "https://api.guangyapan.com"; const GUANGYA_CODE_RES_TOKEN_INSTANT = 156; const GUANGYA_CODE_DIR_EXISTS = 159; const GUANGYA_URL_GET_RES_CENTER_TOKEN = `${GUANGYA_API_BASE}/userres/v1/get_res_center_token`; const GUANGYA_URL_CHECK_FLASH_UPLOAD = `${GUANGYA_API_BASE}/userres/v1/check_can_flash_upload`; const GUANGYA_URL_FLASH_UPLOAD = `${GUANGYA_API_BASE}/userres/v1/flash_upload`; const GUANGYA_URL_CREATE_DIR = `${GUANGYA_API_BASE}/userres/v1/file/create_dir`; const GUANGYA_URL_DELETE_UPLOAD_TASK = `${GUANGYA_API_BASE}/userres/v1/file/delete_upload_task`; const GUANGYA_URL_GET_INFO_BY_TASK_ID = `${GUANGYA_API_BASE}/userres/v1/file/get_info_by_task_id`; const GUANGYA_URL_FILE_LIST = `${GUANGYA_API_BASE}/userres/v1/file/list`; const GUANGYA_URL_FILE_DOWNLOAD = `${GUANGYA_API_BASE}/userres/v1/file/download`; const GUANGYA_URL_FILE_DOWNLOAD_URL = `${GUANGYA_API_BASE}/userres/v1/get_res_download_url`; const GUANGYA_URL_FILE_PREVIEW = `${GUANGYA_API_BASE}/userres/v1/file/preview`; // ========== 抓包模块（集成在主脚本中） v2 ========== const __captureRequests = []; const __captureMaxRequests = 1000; const __captureStorageKey = "__gy_capture_data__"; let __captureNextId = 1; const __captureTargetPatterns = [ "guangyapan.com/userres/", "guangyapan.com/file/", "guangyapan.com/nd.bizuserres", "get_res_center_token", "check_can_flash_upload", "get_info_by_task_id", "flash_upload", "delete_upload_task", "create_dir", "api-pan.xunlei.com", ]; function __captureIsTarget(url) { if (!url) return false; const lower = url.toLowerCase(); return __captureTargetPatterns.some(p => lower.includes(p.toLowerCase())); } function __captureTryParse(str) { if (typeof str !== "string") return str; try { return JSON.parse(str); } catch { return str; } } function __captureAdd(record) { __captureRequests.push(record); if (__captureRequests.length > __captureMaxRequests) { __captureRequests.splice(0, __captureRequests.length - __captureMaxRequests); } try { // 持久化最近 200 条 GM_setValue(__captureStorageKey, JSON.stringify(__captureRequests.slice(-200))); } catch { /* ignore */ } // 控制台调试输出（仅秒传相关接口） try { const isGyApi = /guangyapan\.com/i.test(record.url || ""); if (isGyApi && (record.url.includes("check_can_flash_upload") || record.url.includes("get_res_center_token") || record.url.includes("get_info_by_task_id") || record.url.includes("create_dir") || record.url.includes("delete_upload_task"))) { console.log( `%c[光鸭抓包] ${record.method} ${record.status} ${new URL(record.url).pathname}`, record.status >= 400 || (record.responseBody && record.responseBody.code && record.responseBody.code !== 0 && record.responseBody.code !== 156 && record.responseBody.code !== 159) ? "color:#e74c3c;font-weight:bold" : "color:#27ae60;font-weight:bold", { req: record.requestBody, resp: record.responseBody, duration: record.durationMs } ); } } catch { /* ignore */ } } // ========== 拦截 GM_xmlhttpRequest（核心秒传请求走这里） ========== try { if (typeof GM_xmlhttpRequest === "function") { const __origGM = GM_xmlhttpRequest; console.log("%c[光鸭抓包] GM_xmlhttpRequest 拦截器已挂载", "color:#3498db;font-weight:bold"); GM_xmlhttpRequest = function (details) { const url = (details && details.url) || ""; const method = (details && details.method) || "GET"; const startTime = Date.now(); const isTarget = __captureIsTarget(url); // 非目标：直接透传 if (!isTarget) { return __origGM.call(this, details); } const entry = { id: __captureNextId++, timestamp: new Date().toISOString(), method, url, requestHeaders: (details && details.headers) || {}, requestBody: (details && details.data) ? __captureTryParse(details.data) : null, status: 0, statusText: "", responseBody: null, responseHeaders: "", durationMs: 0, source: "GM_xmlhttpRequest", }; const finishEntry = (resp, extra) => { try { entry.status = resp && typeof resp.status === "number" ? resp.status : 0; entry.statusText = resp && resp.statusText ? resp.statusText : (extra && extra.statusText ? extra.statusText : ""); entry.responseHeaders = resp && resp.responseHeaders ? resp.responseHeaders : ""; entry.durationMs = Date.now() - startTime; const rawText = (resp && resp.responseText) ? resp.responseText : ((extra && extra.responseText) ? extra.responseText : ""); try { entry.responseBody = __captureTryParse(rawText); } catch { entry.responseBody = rawText || ""; } __captureAdd(entry); } catch (e) { try { entry.statusText = "CAPTURE_ERR: " + (e && e.message); __captureAdd(entry); } catch {} } }; // 包装所有可能的回调，确保至少一个能写入记录 const modDetails = Object.assign({}, details); const origOnLoad = modDetails.onload; const origOnError = modDetails.onerror; const origOnTimeout = modDetails.ontimeout; const origOnAbort = modDetails.onabort; let recorded = false; const recordOnce = (resp, extra) => { if (!recorded) { recorded = true; finishEntry(resp, extra); } }; modDetails.onload = function (resp) { recordOnce(resp, null); if (typeof origOnLoad === "function") { try { origOnLoad.call(this, resp); } catch (e) { console.error("[光鸭抓包] GM onload 用户回调报错", e); } } }; modDetails.onerror = function (resp) { recordOnce(resp, { statusText: "NETWORK_ERROR" }); if (typeof origOnError === "function") { try { origOnError.call(this, resp); } catch (e) { console.error("[光鸭抓包] GM onerror 用户回调报错", e); } } }; modDetails.ontimeout = function (resp) { recordOnce(resp || {}, { statusText: "TIMEOUT" }); if (typeof origOnTimeout === "function") { try { origOnTimeout.call(this, resp); } catch (e) { console.error("[光鸭抓包] GM ontimeout 用户回调报错", e); } } }; modDetails.onabort = function (resp) { recordOnce(resp || {}, { statusText: "ABORTED" }); if (typeof origOnAbort === "function") { try { origOnAbort.call(this, resp); } catch (e) { console.error("[光鸭抓包] GM onabort 用户回调报错", e); } } }; // 有些用户代码可能不传 onload 但用 onreadystatechange，兜底 const origOnReadyStateChange = modDetails.onreadystatechange; modDetails.onreadystatechange = function (resp) { if (resp && resp.readyState === 4) { recordOnce(resp, null); } if (typeof origOnReadyStateChange === "function") { try { origOnReadyStateChange.call(this, resp); } catch {} } }; try { return __origGM.call(this, modDetails); } catch (e) { recordOnce({}, { statusText: "THROW: " + (e && e.message ? e.message : String(e)) }); throw e; } }; } else { console.warn("[光鸭抓包] GM_xmlhttpRequest 不可用，无法拦截秒传核心请求！请确保 @grant GM_xmlhttpRequest 已声明"); } } catch (e) { console.error("[光鸭抓包] GM_xmlhttpRequest 拦截挂载失败:", e && e.message ? e.message : e); } // ========== 拦截 fetch（页面原生请求） ========== try { if (unsafeWindow && typeof unsafeWindow.fetch === "function") { const origFetch = unsafeWindow.fetch; unsafeWindow.fetch = function (input, init) { const url = typeof input === "string" ? input : (input && (input.url || input.href)) || ""; const method = (init && init.method) || (input && typeof input.method === "string" ? input.method : "GET"); const headers = (init && init.headers) || (input && input.headers) || {}; let body = null; if (init && init.body != null) { body = init.body; if (typeof body === "string") body = __captureTryParse(body); } const isTarget = __captureIsTarget(url); if (!isTarget) { return origFetch.apply(this, arguments); } const startTime = Date.now(); const entry = { id: __captureNextId++, timestamp: new Date().toISOString(), method, url, requestHeaders: headers, requestBody: body, status: 0, statusText: "", responseBody: null, durationMs: 0, source: "fetch", }; return origFetch.apply(this, arguments).then(async function (resp) { entry.status = resp.status; entry.statusText = resp.statusText; entry.durationMs = Date.now() - startTime; try { const clone = resp.clone(); const text = await clone.text(); entry.responseBody = __captureTryParse(text); } catch { entry.responseBody = "[无法读取响应体]"; } __captureAdd(entry); return resp; }).catch(function (err) { entry.status = 0; entry.statusText = "ERROR: " + (err && err.message ? err.message : String(err)); entry.durationMs = Date.now() - startTime; __captureAdd(entry); throw err; }); }; console.log("%c[光鸭抓包] fetch 拦截器已挂载", "color:#3498db"); } } catch (e) { console.error("[光鸭抓包] fetch 拦截挂载失败:", e); } // ========== 拦截 XMLHttpRequest（页面原生请求） ========== try { const __origOpen = XMLHttpRequest.prototype.open; const __origSetHeader = XMLHttpRequest.prototype.setRequestHeader; const __origSend = XMLHttpRequest.prototype.send; XMLHttpRequest.prototype.open = function (method, url) { this.__gyCap = { method: method || "", url: url || "", startTime: Date.now(), requestBody: null, requestHeaders: {}, }; return __origOpen.apply(this, arguments); }; XMLHttpRequest.prototype.setRequestHeader = function (name, value) { if (this.__gyCap) this.__gyCap.requestHeaders[name] = value; return __origSetHeader.apply(this, arguments); }; XMLHttpRequest.prototype.send = function (body) { if (this.__gyCap) { if (body != null) { this.__gyCap.requestBody = typeof body === "string" ? __captureTryParse(body) : (body instanceof FormData ? "[FormData]" : (body instanceof ArrayBuffer ? "[ArrayBuffer]" : body)); } if (__captureIsTarget(this.__gyCap.url)) { const cap = this.__gyCap; const recorded = { done: false }; const finish = (xhr, statusTextExtra) => { if (recorded.done) return; recorded.done = true; try { const entry = { id: __captureNextId++, timestamp: new Date().toISOString(), method: cap.method, url: cap.url, requestHeaders: cap.requestHeaders, requestBody: cap.requestBody, status: xhr.status || 0, statusText: xhr.statusText || statusTextExtra || "", responseBody: __captureTryParse(xhr.responseText || ""), durationMs: Date.now() - cap.startTime, source: "xhr", }; __captureAdd(entry); } catch {} }; this.addEventListener("load", function () { finish(this, ""); }); this.addEventListener("error", function () { finish(this, "NETWORK_ERROR"); }); this.addEventListener("abort", function () { finish(this, "ABORTED"); }); this.addEventListener("timeout", function () { finish(this, "TIMEOUT"); }); } } return __origSend.apply(this, arguments); }; console.log("%c[光鸭抓包] XMLHttpRequest 拦截器已挂载", "color:#3498db"); } catch (e) { console.error("[光鸭抓包] XMLHttpRequest 拦截挂载失败:", e); } // 导出抓包数据的辅助函数 function __captureExport() { if (__captureRequests.length === 0) { alert("暂无可导出的请求！\n\n请按此步骤操作：\n1. 点击 [🗑️清空] 重置\n2. 点击 [导入JSON] 并选择你的迅雷JSON开始秒传\n3. 等秒传提示完成（或失败）后再点 [📥导出]"); return; } // 核心检查：有没有 GM_xmlhttpRequest（秒传核心请求必须走这个） const gmCount = __captureRequests.filter(r => r.source === "GM_xmlhttpRequest").length; const hasRapidApi = __captureRequests.some(r => (r.url || "").includes("get_res_center_token") || (r.url || "").includes("check_can_flash_upload") || (r.url || "").includes("get_info_by_task_id") ); if (gmCount === 0 || !hasRapidApi) { const msg = "⚠️ 抓包检查提醒：\n\n"; const tips = []; if (gmCount === 0) tips.push("• 没有捕获到 GM_xmlhttpRequest 请求（脚本发起的秒传必须用这个）"); if (!hasRapidApi) tips.push("• 没有捕获到秒传核心接口（get_res_center_token / check_can_flash_upload / get_info_by_task_id）"); tips.push("\n请确认："); tips.push("1. 已点击 [清空] 后再执行导入秒传操作"); tips.push("2. 点击了脚本注入的 [导入JSON] 按钮（不是光鸭原生上传按钮）"); tips.push("3. 等待秒传流程跑完（成功或失败提示都可以）"); tips.push("\n确认后再继续导出吗？"); if (!confirm(msg + tips.join("\n"))) return; } const data = { exportedAt: new Date().toISOString(), scriptVersion: SCRIPT_VERSION, totalRequests: __captureRequests.length, summary: { byEndpoint: {}, bySource: {}, errors: [], rapidTransferCheck: { hasGmRequests: gmCount > 0, gmRequestCount: gmCount, hasRapidApis: hasRapidApi } }, requests: __captureRequests, }; for (const r of __captureRequests) { const path = (r.url || "").split("?")[0]; data.summary.byEndpoint[path] = (data.summary.byEndpoint[path] || 0) + 1; data.summary.bySource[r.source] = (data.summary.bySource[r.source] || 0) + 1; const respCode = r.responseBody && r.responseBody.code; // code 156=瞬时秒传，159=目录已存在，147=上传中，0=msg:success但无code，这些都是正常的 const normalCodes = [0, 156, 159, 147, "0", "156", "159", "147"]; const hasErrStatus = r.status >= 400; const hasErrCode = respCode != null && respCode !== "" && !normalCodes.includes(respCode) && !(r.responseBody && r.responseBody.msg === "success" && respCode == null); if (hasErrStatus || hasErrCode) { data.summary.errors.push({ id: r.id, source: r.source, url: path, httpStatus: r.status, responseCode: respCode != null ? respCode : null, message: r.responseBody ? (r.responseBody.msg || r.responseBody.error || "") : "", requestBody: r.requestBody, responseBody: r.responseBody, }); } } const json = JSON.stringify(data, null, 2); const blob = new Blob([json], { type: "application/json" }); const url = URL.createObjectURL(blob); const a = document.createElement("a"); a.href = url; a.download = `光鸭抓包_${new Date().toISOString().replace(/[:.]/g, "-")}.json`; document.body.appendChild(a); a.click(); setTimeout(() => { URL.revokeObjectURL(url); document.body.removeChild(a); }, 500); } // 清理抓包 UI 面板（移除所有浮动面板、快捷按钮、状态条） function __captureRemoveUI() { const ids = ["gy-cap-panel", "gy-cap-fab", "gy-cap-fab-hint", "gy-cap-statusbar"]; ids.forEach(id => { const el = document.getElementById(id); if (el) el.remove(); }); const styleEl = document.getElementById("gy-cap-style-v2"); if (styleEl) styleEl.remove(); } // 调试工具菜单管理（toggle 模式，兼容不支持 GM_unregisterMenuCommand 的 ScriptCat） const __captureMenuItems = { export: "📥 导出抓包JSON", clear: "🗑️ 清空抓包数据", }; // 调试工具是否开启（ScriptCat 不支持 GM_unregisterMenuCommand，所以菜单项始终显示， // 但关闭时回调会提示未开启，真正生效的逻辑由 __captureDebugEnabled 控制） let __captureDebugEnabled = false; let __captureChildMenusRegistered = false; function __captureRegisterChildMenusOnce() { if (__captureChildMenusRegistered) return; if (typeof GM_registerMenuCommand !== "function") return; try { GM_registerMenuCommand(__captureMenuItems.export, () => { if (!__captureDebugEnabled) { alert("🔕 调试工具未开启。\n\n请先点击菜单：\n🔧 调试工具（开启/关闭）\n开启后再使用本功能。"); return; } try { __captureExport(); } catch (e) { alert("导出失败：" + (e && e.message ? e.message : e)); } }); GM_registerMenuCommand(__captureMenuItems.clear, () => { if (!__captureDebugEnabled) { alert("🔕 调试工具未开启。\n\n请先点击菜单：\n🔧 调试工具（开启/关闭）\n开启后再使用本功能。"); return; } if (__captureRequests.length > 0 && !confirm("确定清空所有抓包数据？")) return; __captureRequests.length = 0; try { if (typeof __captureNextId !== "undefined") __captureNextId = 1; } catch {} try { GM_setValue(__captureStorageKey, "[]"); } catch {} alert("✅ 抓包数据已清空！\n请立即重新执行导入JSON秒传操作。"); }); __captureChildMenusRegistered = true; } catch (e) { console.error("[光鸭抓包] 注册子菜单失败:", e); } } function __captureSetDebugEnabled(enabled) { __captureDebugEnabled = enabled; if (enabled) { __captureRegisterChildMenusOnce(); console.log("%c[光鸭抓包] 调试工具已开启", "color:#4ade80;font-weight:bold"); } else { console.log("%c[光鸭抓包] 调试工具已关闭（子菜单项仍在 ScriptCat 中显示，但点击会提示未开启）", "color:#94a3b8"); } } // 兼容旧函数名（防止其他地方还在调用） const __captureRegisterMenuItems = () => __captureSetDebugEnabled(true); const __captureUnregisterMenuItems = () => __captureSetDebugEnabled(false); // 暴露抓包 API 到全局（方便在控制台手动调试） try { unsafeWindow.__gyCapture = { getData: () => __captureRequests.slice(), export: __captureExport, clear: () => { __captureRequests.length = 0; __captureNextId = 1; }, isTarget: __captureIsTarget, enableMenu: __captureRegisterMenuItems, disableMenu: __captureUnregisterMenuItems, stats: () => ({ total: __captureRequests.length, gmRequests: __captureRequests.filter(r => r.source === "GM_xmlhttpRequest").length, errors: __captureRequests.filter(r => r.status >= 400).length, endpoints: [...new Set(__captureRequests.map(r => (r.url || "").split("?")[0]))], }), }; console.log("%c[光鸭抓包] 全局 API 已挂载：unsafeWindow.__gyCapture", "color:#4caf50;font-weight:bold"); } catch { /* ignore */ } const XUNLEI_API_BASE = "https://api-pan.xunlei.com"; const XUNLEI_CLIENT_ID = "Xqp0kJBXWhwaTpB6"; const BTN_XUNLEI_JSON_ID = "guangya-xunlei-json-btn"; const BTN_XUNLEI_SHARE_JSON_ID = "guangya-xunlei-share-json-btn"; const KEY_GUANGYA_ACCESS_TOKEN = "guangya_guangyapan_access_token"; const KEY_GUANGYA_RECORDED_TOKEN = "guangya_recorded_token"; const KEY_GUANGYA_RECORDED_FOLDER_ID = "guangya_recorded_folder_id"; const KEY_GUANGYA_RECORDED_FOLDER_NAME = "guangya_recorded_folder_name"; // 待云添加的磁力链接（跨页面传递：搜索页存入，光鸭页消费） const KEY_GUANGYA_PENDING_MAGNET = "guangya_pending_magnet"; // 迅雷保存到光鸭的秒传进度（跨标签页持久化 + 断网续跑） const KEY_GUANGYA_SAVE_PROGRESS = "guangya_save_progress"; // 已成功的 md5/gcid 集合（续跑时跳过） const KEY_GUANGYA_SAVE_SUCCESS_SET = "guangya_save_success_set"; const BTN_GUANGYA_IMPORT_ID = "guangya-guangya-import-json-btn"; const BTN_GUANGYA_EXTRACT_ID = "guangya-guangya-extract-json-btn"; const BTN_GUANGYA_SEARCH_ID = "guangya-guangya-search-btn"; const BTN_GUANGYA_RECORD_ID = "guangya-guangya-record-btn"; const INVALID_ETAG_POLICY = localStorage.getItem("guangya_etag_policy") || "skip"; const GUANGYA_BTN_TYPO_STYLE_ID = "guangya-rapid-json-typography"; // 版本号持久化 key（用于检测版本升级后显示更新日志） const KEY_LAST_SHOWN_VERSION = "guangya_last_shown_version"; // 欢迎弹窗联系方式图片（Base64 数据 URL，留空则只显示文字） const __WELCOME_IMG_BASE64__ = "data:image/png;base64,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"; // ============================================================ // 通用工具函数 // ============================================================ function guangyaJsonDetail(obj) { try { return JSON.stringify(obj, null, 2); } catch { return String(obj); } } function makeRapidTransferExportFilename(baseName, totalFiles, totalSize) { let prefix = ""; if (baseName && baseName.trim()) { prefix = baseName.trim().replace(/[\\/:*?"<>|]/g, "_"); } else { const d = new Date(); const p = (n) => String(n).padStart(2, "0"); const date = d.getFullYear() + p(d.getMonth() + 1) + p(d.getDate()); const time = p(d.getHours()) + p(d.getMinutes()) + p(d.getSeconds()); prefix = `秒传_${date}_${time}`; } // 附加文件数和大小信息 const parts = []; if (totalFiles != null && totalFiles > 0) { parts.push(`${totalFiles}个文件`); } if (totalSize != null && totalSize > 0) { parts.push(formatSizeForFilename(totalSize)); } if (parts.length > 0) { prefix += `_${parts.join("_")}`; } return `${prefix}.json`; } function formatSizeForFilename(bytes) { const n = Number(bytes) || 0; if (n >= 1024 * 1024 * 1024) { const gb = (n / (1024 * 1024 * 1024)).toFixed(2).replace(/\.?0+$/, ""); return `${gb}G`; } if (n >= 1024 * 1024) { const mb = (n / (1024 * 1024)).toFixed(1).replace(/\.?0+$/, ""); return `${mb}M`; } if (n >= 1024) { const kb = Math.round(n / 1024); return `${kb}K`; } return `${n}B`; } /** * 从收集的文件列表推断导出文件名前缀 * 规则： * - 所有文件在同一个根文件夹 → 根文件夹名 * - 多个根文件/文件夹 → 当前目录名_等N个项 * - 单个文件 → 文件名（去扩展名） */ function inferExportBaseName(files, currentFolderName) { if (!files || !files.length) return ""; const curName = String(currentFolderName || "").trim(); // 收集所有 path 的顶层目录 const topLevelSet = new Set(); const topLevelFileSet = new Set(); let hasSubFolder = false; for (const f of files) { const p = String(f.path || ""); if (!p) continue; const parts = p.split("/").filter(Boolean); if (parts.length === 0) continue; if (parts.length === 1) { topLevelFileSet.add(parts[0]); } else { topLevelSet.add(parts[0]); hasSubFolder = true; } } // 情况1：只有1个顶层文件夹（所有文件都在同一个子文件夹下） if (topLevelSet.size === 1 && topLevelFileSet.size === 0) { const folderName = [...topLevelSet][0]; return folderName; } // 情况2：只有1个顶层文件 if (topLevelSet.size === 0 && topLevelFileSet.size === 1) { const fileName = [...topLevelFileSet][0]; // 去掉扩展名 return fileName.replace(/\.[^.]+$/, ""); } // 情况3：多个顶层项（文件+文件夹混合，或多个文件夹） const totalTop = topLevelSet.size + topLevelFileSet.size; if (totalTop > 1) { const base = curName || "秒传"; return `${base}_等${totalTop}个项`; } // 情况4：只有顶层文件夹 + 顶层文件混合 → 用当前目录名 if (totalTop === 1) { if (topLevelSet.size === 1) return [...topLevelSet][0]; if (topLevelFileSet.size === 1) { const fn = [...topLevelFileSet][0]; return fn.replace(/\.[^.]+$/, ""); } } return curName || ""; } function guangyaCreateTraceparent() { const hex = (len) => { const u = new Uint8Array(len); crypto.getRandomValues(u); return [...u].map((b) => b.toString(16).padStart(2, "0")).join(""); }; return `00-${hex(16)}-${hex(8)}-01`; } /** 秒传导入 JSON 文件/文本结构校验 */ function validateGuangyaImportJsonShape(text) { const trim = String(text || "").trim(); if (!trim) return { ok: false, message: "文件内容为空" }; let obj; try { obj = JSON.parse(trim); } catch { return { ok: false, message: "不是合法 JSON（请检查编码、逗号、引号与括号是否匹配）" }; } if (obj == null || typeof obj !== "object" || Array.isArray(obj)) { return { ok: false, message: "JSON 顶层须为对象 { … }，不能是数组或纯数字/字符串" }; } if (!Array.isArray(obj.files)) { return { ok: false, message: '须包含数组字段 files，例如：{"files":[{"path":"…","etag":"…","size":0},…]} 或迅雷格式：{"files":[{"path":"…","gcid":"…","size":0},…]}', }; } if (obj.files.length === 0) return { ok: false, message: "files 数组长度为 0，没有可导入条目" }; const badIdx = []; for (let i = 0; i < obj.files.length; i++) { const it = obj.files[i]; if (it == null || typeof it !== "object" || Array.isArray(it)) { badIdx.push(i); if (badIdx.length >= 8) break; } } if (badIdx.length) { const sample = badIdx.slice(0, 5).join("、"); const more = badIdx.length > 5 ? ` 等共 ${badIdx.length} 处` : ""; return { ok: false, message: `files 中第 ${sample} 项${more}不是对象，每项应为 { path/name, etag/md5, size }` }; } return { ok: true, fileCount: obj.files.length }; } function guangyaBasenameFromPath(filePath) { const s = String(filePath || "").replace(/\\/g, "/"); const parts = s.split("/").filter(Boolean); return parts.length ? parts[parts.length - 1] : "file"; } function guangyaDirSegmentsFromPath(filePath) { const s = String(filePath || "").replace(/\\/g, "/"); const parts = s.split("/").map((p) => String(p || "").trim()).filter((p) => p.length > 0); if (parts.length <= 1) return []; return parts.slice(0, -1); } function guangyaPickFileIdFromObj(obj) { if (!obj || typeof obj !== "object") return ""; const id = obj.fileId ?? obj.fileid ?? obj.file_id ?? obj.id ?? obj.dirId ?? obj.dir_id ?? obj.folderId ?? obj.folder_id; return id == null ? "" : String(id); } function guangyaNormMd5Token(m) { return String(m == null ? "" : m).trim().toLowerCase(); } function guangyaExtractMd5FromEtag(raw) { const s = String(raw ?? "").trim(); if (!s) return { ok: false, reason: "etag/md5 为空" }; const lower = s.toLowerCase(); if (/^[0-9a-f]{32}$/.test(lower)) return { ok: true, md5: lower }; return { ok: false, reason: `etag 长度 ${s.length} 位，应为标准 32 位十六进制 MD5` }; } function isGuangyaForbiddenNameError(err) { if (!err) return false; try { const detail = JSON.parse(String(err.guangyaDetail || "{}")); const rb = detail && detail.responseBody; if (rb && typeof rb === "object" && rb.code === 166) return true; } catch { /* ignore */ } return false; } function formatGuangyaImportCopyReport(parts) { const iface = parts.interfaceLines; const xfer = parts.transferRows || []; const mkdirSkip = parts.mkdirSkipLines || []; const validateSkip = parts.validateSkipLines || []; const extra = parts.transferExtraLines || []; const lines = []; lines.push("========== 接口调用失败 =========="); if (iface && iface.length) lines.push(...iface.map((x) => String(x))); else lines.push("（无）"); lines.push(""); lines.push("========== 秒传失败 =========="); if (xfer.length) { for (const r of xfer) { const p = String(r.filePath || "").trim(); lines.push(p ? `${r.md5} ${p}` : `${r.md5}`); } } else lines.push("（无）"); lines.push(""); lines.push("========== 创建目录失败 =========="); if (mkdirSkip.length) lines.push(...mkdirSkip); else lines.push("（无）"); lines.push(""); lines.push("========== 校验未通过 =========="); if (validateSkip.length) lines.push(...validateSkip); else lines.push("（无）"); if (extra.length) { lines.push(""); lines.push(...extra); } return lines.join("\n"); } // ============================================================ // helper 对象：网络请求、对话框、JSON 生成 // ============================================================ const helper = { sleep(ms) { return new Promise((resolve) => setTimeout(resolve, ms)); }, // 🛡️【关键】迅雷 API 从 2026 年 7 月底开始强制要求 device_id 非空： // 缺 X-Device-Id 头或 query 参数就直接返回 400 invalid_argument（detail: device_id is empty） // 这里统一生成一个稳定的 deviceId（跨会话不变，否则触发风控），并： // 1) 所有请求头自动加 x-device-id / X-Device-Id / x-guid（大小写双写，兼容不同后端分支） // 2) 迅雷 URL 自动拼 device_id=... & did=... & guid=...（双保险，避免某些老后端分支不读 header） _ensureStableDeviceId() { const KEY = "xunlei_device_id_stable_v1"; // 🔑 支持两种合法格式： // · 32位 hex（helper 自生成的稳定值） // · 迅雷 Web 版 deviceId（wdi/ wd + 8+ hex，和 captcha_token 绑定） const isValidDid = (s) => /^[0-9a-fA-F]{32}$/.test(String(s)) || /^wd[a-z0-9._-]{10,}/i.test(String(s)); // 🔑 【最高优先级】先从 panXunlei 拦截器捕获的真实 deviceId 读取 // captcha_token 是和这个 deviceId 绑定的，必须统一，否则 "device not match" try { if (typeof GM_getValue === "function") { const intercepted = GM_getValue("xunlei_device_id_intercepted", ""); if (intercepted && isValidDid(intercepted)) { // 同步写入 stable key，下次直接命中 try { GM_setValue(KEY, intercepted); } catch {} return String(intercepted); } } } catch {} try { if (typeof GM_getValue === "function") { const cached = GM_getValue(KEY, ""); if (cached && isValidDid(cached)) return String(cached); } } catch {} try { const ls = localStorage.getItem(KEY); if (ls && isValidDid(ls)) return String(ls); } catch {} // 生成：优先用 crypto.getRandomValues（32 位 hex = 128 bit） let hex = ""; try { const arr = new Uint8Array(16); if (window.crypto && typeof window.crypto.getRandomValues === "function") { window.crypto.getRandomValues(arr); for (let i = 0; i < arr.length; i++) hex += arr[i].toString(16).padStart(2, "0"); } } catch {} if (hex.length !== 32) { hex = ""; while (hex.length < 32) hex += Math.floor(Math.random() * 16).toString(16); } hex = hex.toLowerCase(); try { if (typeof GM_setValue === "function") GM_setValue(KEY, hex); } catch {} try { localStorage.setItem(KEY, hex); } catch {} return hex; }, /** 🔑 覆盖稳定 deviceId（当 bootstrap 挖到 Web 版 wd110.xxx 时调用，保持跨会话一致 + 和 captcha 绑定） */ _setStableDeviceId(v) { const KEY = "xunlei_device_id_stable_v1"; if (!v || typeof v !== "string") return; const ts = String(v).trim(); if (!ts) return; try { if (typeof GM_setValue === "function") GM_setValue(KEY, ts); } catch {} try { localStorage.setItem(KEY, ts); } catch {} // 🔑 同时写入 panXunlei 拦截器的 key，保证双 key 同步 try { if (typeof GM_setValue === "function") GM_setValue("xunlei_device_id_intercepted", ts); } catch {} }, /** 向 URL 追加 device_id/did/guid query 参数（只针对迅雷 URL） */ _attachDeviceQuery(url, deviceId) { if (!url || typeof url !== "string") return url; if (!/api-pan\.xunlei\.com/i.test(url)) return url; const did = String(deviceId || "").trim(); if (!did) return url; const sep = url.includes("?") ? "&" : "?"; // 迅雷实际抓到的请求里会同时带 did= 和 device_id=，这里也都带上，少哪个补哪个（避免重复） const parts = []; if (!/(^|[?&])device_id=/.test(url)) parts.push(`device_id=${encodeURIComponent(did)}`); if (!/(^|[?&])did=/.test(url)) parts.push(`did=${encodeURIComponent(did)}`); if (!/(^|[?&])guid=/.test(url)) parts.push(`guid=${encodeURIComponent(did)}`); if (!parts.length) return url; return url + sep + parts.join("&"); }, /** 向 headers 注入 x-device-id / x-guid（只针对迅雷 URL），大小写双写提高兼容性 */ _attachDeviceHeaders(url, headers, deviceId) { if (!/api-pan\.xunlei\.com/i.test(url || "")) return headers; const did = String(deviceId || "").trim(); if (!did) return headers; const out = (headers && typeof headers === "object") ? { ...headers } : {}; // 迅雷 Access-Control-Allow-Headers 里写的是：X-Device-Id,X-Guid 等，大小写都写一遍 if (!out["x-device-id"]) out["x-device-id"] = did; if (!out["X-Device-Id"]) out["X-Device-Id"] = did; if (!out["x-guid"]) out["x-guid"] = did; if (!out["X-Guid"]) out["X-Guid"] = did; return out; }, get(url, headers = {}) { return new Promise((resolve, reject) => { const did = this._ensureStableDeviceId(); const finalUrl = this._attachDeviceQuery(url, did); const finalHeaders = this._attachDeviceHeaders(url, headers, did); GM_xmlhttpRequest({ method: "GET", url: finalUrl, headers: finalHeaders, onload: (resp) => { if (resp.status >= 200 && resp.status < 300) { resolve(resp.responseText); return; } // 错误信息里附带 body 的 error_description / error_details.detail，便于后续快速判断 let short = ""; try { const j = JSON.parse(resp.responseText || "null"); if (j) { const parts = []; if (j.error) parts.push(String(j.error)); if (j.error_description) parts.push(String(j.error_description)); if (Array.isArray(j.error_details)) { for (const d of j.error_details) { if (d && d.detail) parts.push(String(d.detail)); } } if (parts.length) short = `（${parts.join(" / ")}）`; } } catch {} reject(new Error(`请求失败: ${resp.status}${short}${finalUrl !== url ? ` URL=${String(finalUrl).slice(0, 220)}` : ""}`)); }, onerror: () => reject(new Error("网络请求失败")), }); }); }, postJson(url, data, headers = {}) { return new Promise((resolve, reject) => { const did = (typeof helper === "object" && helper && typeof helper._ensureStableDeviceId === "function") ? helper._ensureStableDeviceId() : ""; let finalUrl = url; if (did && typeof helper === "object" && helper && typeof helper._attachDeviceQuery === "function") { finalUrl = helper._attachDeviceQuery(url, did); } let finalHeaders = headers; if (did && typeof helper === "object" && helper && typeof helper._attachDeviceHeaders === "function") { finalHeaders = helper._attachDeviceHeaders(url, headers, did); } GM_xmlhttpRequest({ method: "POST", url: finalUrl, headers: { "Content-Type": "application/json;charset=utf-8", ...finalHeaders }, data: JSON.stringify(data), onload: (resp) => { try { resolve(JSON.parse(resp.responseText)); } catch { reject(new Error("响应解析失败")); } }, onerror: () => reject(new Error("网络请求失败")), }); }); }, /** * 光鸭云盘专用 POST：自动加 Bearer token、traceparent，处理业务 code。 * @param {{ allowedBusinessCodes?: number[] }} options 若业务 code 非 0，需在此列出仍视为成功的 code（如 156） */ postJsonGuangya(url, data, bearerToken, options) { const tok = String(bearerToken || "").replace(/^Bearer\s+/i, "").trim(); const traceparent = guangyaCreateTraceparent(); const origin = typeof location !== "undefined" ? location.origin : ""; const referer = typeof location !== "undefined" ? location.href : ""; const requestHeaders = { "Content-Type": "application/json;charset=utf-8", Authorization: `Bearer ${tok}`, dt: "4", traceparent, ...(origin ? { Origin: origin } : {}), ...(referer ? { Referer: referer } : {}), }; const headersForLog = { ...requestHeaders }; const bodyStr = JSON.stringify(data); const attachDetail = (err, extra) => { err.guangyaDetail = guangyaJsonDetail({ summary: err.message, url, method: "POST", requestHeaders: headersForLog, requestBody: data, ...extra, }); return err; }; return new Promise((resolve, reject) => { GM_xmlhttpRequest({ method: "POST", url, headers: requestHeaders, data: bodyStr, onload: (resp) => { const raw = resp.responseText || ""; let parsedBody; try { parsedBody = JSON.parse(raw); } catch { parsedBody = null; } if (resp.status < 200 || resp.status >= 300) { let short = raw; try { const ej = JSON.parse(raw); short = ej.msg || ej.message || (typeof ej.error === "string" ? ej.error : "") || ej.error_description || raw; } catch { /* empty */ } reject(attachDetail(new Error(`HTTP ${resp.status}${short ? `: ${String(short).slice(0, 600)}` : ""}`), { httpStatus: resp.status, responseBody: parsedBody ?? raw })); return; } let j; try { j = JSON.parse(resp.responseText); } catch { reject(attachDetail(new Error("响应解析失败"), { httpStatus: resp.status, responseTextPreview: raw.slice(0, 12000) })); return; } const allowed = options && options.allowedBusinessCodes; const businessOk = j.code == null || j.code === 0 || (Array.isArray(allowed) && allowed.includes(j.code)); if (j && j.code != null && !businessOk) { reject(attachDetail(new Error(j.msg || `接口错误 code=${j.code}`), { httpStatus: resp.status, responseBody: j })); return; } resolve({ data: j, requestLog: { url, method: "POST", requestHeaders: headersForLog, requestBody: data } }); }, onerror: () => reject(attachDetail(new Error("网络请求失败"), { networkError: true })), }); }); }, /** 光鸭云盘专用 GET：自动加 Bearer token */ getGuangya(url, bearerToken) { const tok = String(bearerToken || "").replace(/^Bearer\s+/i, "").trim(); const origin = typeof location !== "undefined" ? location.origin : ""; const referer = typeof location !== "undefined" ? location.href : ""; const headers = { Authorization: `Bearer ${tok}`, dt: "4", traceparent: guangyaCreateTraceparent(), ...(origin ? { Origin: origin } : {}), ...(referer ? { Referer: referer } : {}), }; return new Promise((resolve, reject) => { GM_xmlhttpRequest({ method: "GET", url, headers, onload: (resp) => { const raw = resp.responseText || ""; if (resp.status < 200 || resp.status >= 300) { reject(new Error(`HTTP ${resp.status}: ${raw.slice(0, 400)}`)); return; } try { resolve(JSON.parse(raw)); } catch { reject(new Error("响应解析失败")); } }, onerror: () => reject(new Error("网络请求失败")), }); }); }, /** * 计算文件的 SHA-1 哈希（单份整体） */ async sha1Whole(arrayBuffer) { const hashBuffer = await crypto.subtle.digest("SHA-1", arrayBuffer); const hashBytes = new Uint8Array(hashBuffer); return Array.from(hashBytes).map(b => b.toString(16).padStart(2, "0")).join(""); }, /** * 计算 cid（3×20KB采样SHA-1，标准算法） * cid = SHA-1(文件前20KB + 文件1/3位置20KB + 文件末尾20KB) * 对于 <60KB 的小文件，采样会重叠或重复 * 返回格式：{ tripleCid, wholeCid } 以便调用者尝试两种候选 */ async computeCidFromArrayBuffer(arrayBuffer, fileSize) { const SAMPLE_SIZE = 20 * 1024; // 20KB const size = Number(fileSize) || arrayBuffer.byteLength; const u8 = new Uint8Array(arrayBuffer); let s1, s2, s3; if (size <= SAMPLE_SIZE) { s1 = u8.slice(0, size); s2 = u8.slice(0, size); s3 = u8.slice(0, size); } else if (size <= SAMPLE_SIZE * 2) { s1 = u8.slice(0, SAMPLE_SIZE); const midStart = Math.floor(size / 3); s2 = u8.slice(midStart, Math.min(midStart + SAMPLE_SIZE, size)); s3 = u8.slice(Math.max(0, size - SAMPLE_SIZE), size); } else { s1 = u8.slice(0, SAMPLE_SIZE); const midStart = Math.floor(size / 3); s2 = u8.slice(midStart, midStart + SAMPLE_SIZE); s3 = u8.slice(size - SAMPLE_SIZE, size); } const totalLen = s1.length + s2.length + s3.length; const combined = new Uint8Array(totalLen); combined.set(s1, 0); combined.set(s2, s1.length); combined.set(s3, s1.length + s2.length); const tripleHash = await crypto.subtle.digest("SHA-1", combined); const tripleCid = Array.from(new Uint8Array(tripleHash)).map(b => b.toString(16).padStart(2, "0")).join(""); // 同时计算整个文件的单份 SHA-1（小文件备选方案） const wholeHash = await crypto.subtle.digest("SHA-1", arrayBuffer); const wholeCid = Array.from(new Uint8Array(wholeHash)).map(b => b.toString(16).padStart(2, "0")).join(""); return { tripleCid, wholeCid }; }, /** * 下载光鸭云盘文件的 3×20KB 样本并计算 cid * 仅下载最多 60KB，而非整个文件 * 返回 { tripleCid, wholeCid, wholeFileBuffer?, downloadUrl? } * wholeFileBuffer 仅在文件 <= 100MB 时提供，用于 OSS 实际上传兜底 * downloadUrl 提供以便外部复用 */ async downloadAndComputeCid(fileId, fileSize, bearerToken) { const SAMPLE_SIZE = 20 * 1024; const WHOLE_FILE_MAX = 100 * 1024 * 1024; // 100MB 以内才下载整个文件 const rawTok = String(bearerToken || "").trim(); if (!rawTok || rawTok === "undefined" || rawTok === "null") { console.warn("[光鸭秒传] ❌ helper.downloadAndComputeCid: token 无效（" + rawTok.slice(0, 30) + "），无法调用 get_res_download_url"); return { tripleCid: "", wholeCid: "", downloadUrl: "", wholeFileBuffer: undefined }; } const tok = rawTok.replace(/^Bearer\s+/i, "").trim(); const headers = { Authorization: `Bearer ${tok}`, dt: "4", traceparent: guangyaCreateTraceparent(), ...(typeof location !== "undefined" && location.origin ? { Origin: location.origin } : {}), ...(typeof location !== "undefined" && location.href ? { Referer: location.href } : {}), }; // 尝试获取下载链接（光鸭网盘实际接口优先） let downloadUrl = null; const urlCandidates = [ GUANGYA_URL_FILE_DOWNLOAD_URL, // get_res_download_url（光鸭网盘实际使用的下载接口） GUANGYA_URL_FILE_DOWNLOAD, GUANGYA_URL_FILE_PREVIEW, ]; console.log(`[光鸭秒传] 📡 helper.downloadAndComputeCid 开始：fileId=${fileId} size=${fileSize} tokenLen=${tok.length} urlCandidates=${urlCandidates.length}`); for (const dlUrl of urlCandidates) { try { console.log(`[光鸭秒传] 📡 尝试 get_res_download_url：${String(dlUrl).slice(-40)}… fileId=${fileId}`); const resp = await new Promise((resolve, reject) => { GM_xmlhttpRequest({ method: "POST", url: dlUrl, headers: { ...headers, "Content-Type": "application/json;charset=utf-8" }, data: JSON.stringify({ fileId: String(fileId) }), onload: (r) => { try { const j = JSON.parse(r.responseText); // 光鸭返回 {msg:"success", data:{signedURL:"..."}}，无 code 字段 if (j.code === 0 || !j.code || j.msg === "success") { const candidates = [ j.data?.signedURL, // 光鸭网盘实际返回的字段名 j.data?.url, j.data?.downloadUrl, j.data?.download_url, j.data?.signedUrl, j.data?.signed_url, j.data?.presignedUrl, j.data?.presigned_url, j.url, j.downloadUrl, j.download_url, ]; const found = candidates.find(u => typeof u === "string" && u.startsWith("http")); if (found) { resolve({ url: found, headers: j.data?.headers || {} }); return; } } resolve(null); } catch { resolve(null); } }, onerror: () => resolve(null), }); }); if (resp && resp.url) { downloadUrl = resp; break; } } catch { /* 继续尝试下一个 */ } } if (!downloadUrl) { console.warn("[光鸭秒传] 无法获取文件下载链接，cid 计算失败（fileId=" + String(fileId) + "，将用 gcid+md5 兜底尝试秒传）"); return { tripleCid: "", wholeCid: "", downloadUrl: "", wholeFileBuffer: undefined }; } const size = Number(fileSize) || 0; if (!size) { console.warn("[光鸭秒传] cid计算：文件大小为0，跳过"); return { tripleCid: "", wholeCid: "", downloadUrl: downloadUrl.url || "", wholeFileBuffer: undefined }; } // 整个文件内容（小文件时一并下载，用于后续OSS上传兜底或wholeCid计算） let wholeFileBuffer = null; const shouldDownloadWhole = size <= WHOLE_FILE_MAX; if (shouldDownloadWhole) { // 直接下载整个文件（一次性获取，省掉多次Range请求） console.log(`[光鸭秒传] 文件大小 ${this.formatSize(size)} <= 100MB，直接下载整个文件`); try { const fetchResp = await fetch(downloadUrl.url, { method: "GET", headers: downloadUrl.headers, mode: "cors", credentials: "omit", }); if (fetchResp && (fetchResp.status === 200 || fetchResp.status === 206)) { wholeFileBuffer = await fetchResp.arrayBuffer(); } else { console.warn(`[光鸭秒传] 下载整个文件失败，HTTP状态=${fetchResp?.status}`); } } catch (fe) { console.warn(`[光鸭秒传] fetch下载整个文件失败，退回GM_xmlhttpRequest：${String(fe?.message||fe).slice(0,120)}`); // 兜底 GM_xmlhttpRequest 下载整个文件 try { wholeFileBuffer = await new Promise((resolve, reject) => { GM_xmlhttpRequest({ method: "GET", url: downloadUrl.url, headers: downloadUrl.headers, responseType: "arraybuffer", onload: (r) => { if (r.status === 200 || r.status === 206) resolve(r.response || new ArrayBuffer(0)); else resolve(null); }, onerror: () => resolve(null), ontimeout: () => resolve(null), timeout: 120000, // 2分钟超时 }); }); } catch { wholeFileBuffer = null; } } if (wholeFileBuffer && wholeFileBuffer.byteLength !== size) { console.warn(`[光鸭秒传] 整个文件大小不匹配：期望${size}，实际${wholeFileBuffer.byteLength}，仍继续使用`); } } // 构造 3×20KB 样本或使用已下载的完整文件切片 let sampleCombined; if (wholeFileBuffer) { // 从整个文件切出采样区拼接 const u8 = new Uint8Array(wholeFileBuffer); let s1, s2, s3; if (size <= SAMPLE_SIZE) { s1 = u8.slice(0, size); s2 = u8.slice(0, size); s3 = u8.slice(0, size); } else if (size <= SAMPLE_SIZE * 2) { s1 = u8.slice(0, SAMPLE_SIZE); const midStart = Math.floor(size / 3); s2 = u8.slice(midStart, Math.min(midStart + SAMPLE_SIZE, size)); s3 = u8.slice(Math.max(0, size - SAMPLE_SIZE), size); } else { s1 = u8.slice(0, SAMPLE_SIZE); const midStart = Math.floor(size / 3); s2 = u8.slice(midStart, midStart + SAMPLE_SIZE); s3 = u8.slice(size - SAMPLE_SIZE, size); } const totalLen = s1.length + s2.length + s3.length; sampleCombined = new Uint8Array(totalLen); sampleCombined.set(s1, 0); sampleCombined.set(s2, s1.length); sampleCombined.set(s3, s1.length + s2.length); } else { // 大文件：分 3 段 Range 下载 const ranges = []; ranges.push({ start: 0, end: SAMPLE_SIZE - 1 }); const midStart = Math.floor(size / 3); const midEnd = Math.min(midStart + SAMPLE_SIZE - 1, size - 1); ranges.push({ start: midStart, end: midEnd }); const lastStart = Math.max(0, size - SAMPLE_SIZE); ranges.push({ start: lastStart, end: size - 1 }); console.log(`[光鸭秒传] cid计算：准备下载 ${ranges.length} 个样本片段（文件>100MB），总大小=${this.formatSize(size)}`); const sampleChunks = []; for (let ri = 0; ri < ranges.length; ri++) { const range = ranges[ri]; let chunk = null; const rangeHeader = `bytes=${range.start}-${range.end}`; try { const fetchResp = await fetch(downloadUrl.url, { method: "GET", headers: { ...downloadUrl.headers, Range: rangeHeader }, mode: "cors", credentials: "omit", }); if (fetchResp && (fetchResp.status === 200 || fetchResp.status === 206)) { const ab = await fetchResp.arrayBuffer(); if (ab && ab.byteLength > 0) chunk = ab; } console.log(`[光鸭秒传] cid计算：fetch下载样本${ri+1}/${ranges.length} 区间=${range.start}-${range.end}，状态=${fetchResp?.status}，大小=${chunk?.byteLength || 0}`); } catch { /* 忽略 */ } if (!chunk) { try { chunk = await new Promise((resolve, reject) => { GM_xmlhttpRequest({ method: "GET", url: downloadUrl.url, headers: { ...downloadUrl.headers, Range: rangeHeader }, responseType: "arraybuffer", onload: (r) => { if (r.status === 200 || r.status === 206) resolve(r.response || new ArrayBuffer(0)); else resolve(null); }, onerror: () => resolve(null), ontimeout: () => resolve(null), timeout: 20000, }); }); } catch { chunk = null; } } if (chunk && chunk.byteLength > 0) sampleChunks.push(chunk); } if (sampleChunks.length < 2) { console.warn("[光鸭秒传] cid计算：Range样本下载严重不足（" + sampleChunks.length + "/3），返回空但保留 downloadUrl/wholeFileBuffer 供 OSS 兜底"); return { tripleCid: "", wholeCid: "", downloadUrl: downloadUrl.url || "", wholeFileBuffer: wholeFileBuffer || undefined }; } const totalLen = sampleChunks.reduce((s, c) => s + (c ? c.byteLength : 0), 0); sampleCombined = new Uint8Array(totalLen); let off = 0; for (const c of sampleChunks) { if (!c) continue; sampleCombined.set(new Uint8Array(c), off); off += c.byteLength; } } // 计算 cid（两种候选） let tripleCid = "", wholeCid = ""; try { const res = await this.computeCidFromArrayBuffer(sampleCombined.buffer, size); tripleCid = res.tripleCid; wholeCid = res.wholeCid; } catch (e) { console.warn("[光鸭秒传] cid计算异常：", e); } // 若有整个文件，wholeCid 直接从整个文件再算一次（更准确） if (wholeFileBuffer) { try { wholeCid = await this.sha1Whole(wholeFileBuffer); } catch {} } console.log(`[光鸭秒传] 文件 ${fileId} 计算完成：tripleCid=${tripleCid}，wholeCid=${wholeCid}，有wholeFile=${!!wholeFileBuffer}`); return { tripleCid, wholeCid, wholeFileBuffer: wholeFileBuffer || undefined, downloadUrl: downloadUrl.url, }; }, /** * 下载一块字节，优先 fetch，失败退回 GM_xmlhttpRequest。 * 支持 downloadUrl（字符串）或 {url, headers}。 */ async _downloadByteRange(downloadSource, start, end) { const dlUrl = typeof downloadSource === "string" ? downloadSource : downloadSource?.url; const extraHeaders = (typeof downloadSource === "object" && downloadSource?.headers) ? downloadSource.headers : {}; const rangeHeader = `bytes=${start}-${end}`; const urlTag = String(dlUrl || "").slice(0, 60); // 迅雷 CDN 需要 Referer 头，否则 403 const cdnHeaders = { ...extraHeaders, "Referer": "https://pan.xunlei.com/", "Origin": "https://pan.xunlei.com/" }; // 迅雷 CDN URL 自带 rg= 范围参数（如 rg=0-10485759），不支持 Range 头 → 修改 URL 的 rg 值 const hasRg = dlUrl && /[?&]rg=\d+-\d+/i.test(dlUrl); // 策略：先尝试修改 rg 参数（能精确取到任意位置），403 则回退到原始 URL + Range 头（在 rg 范围内） const tryUrls = []; if (hasRg) { const modifiedUrl = dlUrl.replace(/([?&]rg=)\d+-\d+/i, `$1${start}-${end}`); tryUrls.push({ url: modifiedUrl, useRange: false, label: "修改rg" }); // 回退：原始 URL + Range 头（只有 Range 在原始 rg 范围内才能成功） tryUrls.push({ url: dlUrl, useRange: true, label: "原始URL+Range" }); } else { tryUrls.push({ url: dlUrl, useRange: true, label: "Range" }); } for (const { url: tryUrl, useRange, label } of tryUrls) { const hdrs = useRange ? { ...cdnHeaders, Range: rangeHeader } : { ...cdnHeaders }; // 1) fetch 尝试（可能 CORS 失败） if (useRange) { try { const r = await fetch(tryUrl, { method: "GET", headers: hdrs, mode: "cors", credentials: "omit" }); if (r && (r.status === 200 || r.status === 206)) { const ab = await r.arrayBuffer(); if (ab && ab.byteLength > 0) { console.log(`[光鸭秒传] ✅ fetch ${label} 下载成功：${urlTag}… status=${r.status} bytes=${ab.byteLength}`); return ab; } } } catch { /* CORS, 走 GM_xhr */ } } // 2) GM_xmlhttpRequest const result = await new Promise((resolve) => { GM_xmlhttpRequest({ method: "GET", url: tryUrl, headers: hdrs, responseType: "arraybuffer", onload: (r) => { if (r.status === 200 || r.status === 206) { console.log(`[光鸭秒传] ✅ GM_xhr ${label} 下载成功：${urlTag}… status=${r.status} bytes=${(r.response||{}).byteLength||0}`); resolve(r.response || new ArrayBuffer(0)); } else { console.warn(`[光鸭秒传] GM_xhr ${label} 失败：${urlTag}… status=${r.status}`); resolve(null); } }, onerror: () => resolve(null), ontimeout: () => resolve(null), timeout: 120000, }); }); if (result) return result; } return null; }, /** * PUT 上传一块到 OSS 对象 URL。 * contentLength 若提供则会设置；不设置则由浏览器自行计算。 */ async _putToOssUrl(ossUrl, bodyBuffer, extraHeaders) { const u8 = new Uint8Array(bodyBuffer); try { const r = await fetch(ossUrl, { method: "PUT", mode: "cors", credentials: "omit", headers: { "Content-Type": "application/octet-stream", ...(extraHeaders || {}) }, body: u8, }); return (r.status >= 200 && r.status < 300) ? true : false; } catch { /* ignore */ } return new Promise((resolve) => { GM_xmlhttpRequest({ method: "PUT", url: ossUrl, headers: { "Content-Type": "application/octet-stream", ...(extraHeaders || {}) }, data: u8.buffer, onload: (rr) => resolve(rr.status >= 200 && rr.status < 300), onerror: () => resolve(false), ontimeout: () => resolve(false), timeout: 180000, }); }); }, /** * 大文件（>100MB）流式上传兜底：按 8MB 一块从源下载，立即 PUT 到 OSS 对象 URL 的对应 byte-range。 * 不需要把整个文件放进内存；失败不抛异常。 * downloadSource: string | {url, headers} —— 源下载地址（get_res_download_url 返回的 signedURL） * fileSize: number * tokenBodyData: get_res_center_token.data（取 fullEndPoint + objectPath 拼 OSS URL） */ async tryUploadOssStreaming(downloadSource, fileSize, tokenBodyData) { const CHUNK = 8 * 1024 * 1024; // 8MB if (!downloadSource || !fileSize || !tokenBodyData) return false; const ep = tokenBodyData.fullEndPoint || ""; const op = tokenBodyData.objectPath || ""; if (!ep || !op) return false; const ossUrl = op.startsWith("/") ? `${ep}${op}` : `${ep}/${op}`; const total = Number(fileSize); console.log(`[光鸭秒传] 兜底：开始流式 ${this.formatSize(CHUNK)}/块上传 ${this.formatSize(total)} -> ${ossUrl.slice(0,100)}...`); let offset = 0; let chunkNo = 0; let lastPct = -1; const t0 = Date.now(); while (offset < total) { const start = offset; const end = Math.min(start + CHUNK - 1, total - 1); const expectedLen = end - start + 1; chunkNo++; const buf = await this._downloadByteRange(downloadSource, start, end); if (!buf || buf.byteLength !== expectedLen) { // 兜底：如果 Range 不支持（CDN 返回整文件），且第一次就返回了整个文件，则直接一次性 PUT if (chunkNo === 1 && buf && buf.byteLength === total) { const ok = await this._putToOssUrl(ossUrl, buf); console.log(`[光鸭秒传] 兜底：CDN 未支持 Range，整文件一次性上传结果=${ok}`); return ok; } console.warn(`[光鸭秒传] 兜底：第${chunkNo}块 [${start}-${end}] 下载异常（期望${expectedLen}，实际${buf?.byteLength || 0}），重试 1 次`); const buf2 = await this._downloadByteRange(downloadSource, start, end); if (!buf2 || buf2.byteLength !== expectedLen) { console.warn(`[光鸭秒传] 兜底：第${chunkNo}块重试仍失败，终止上传`); return false; } const ok = await this._putToOssUrl(ossUrl, buf2, { "Content-Range": `bytes ${start}-${end}/${total}`, "Content-Length": String(expectedLen), }); if (!ok) { console.warn(`[光鸭秒传] 兜底：第${chunkNo}块上传失败`); return false; } offset = end + 1; const pct = Math.floor(offset * 100 / total); if (pct !== lastPct) { lastPct = pct; console.log(`[光鸭秒传] 流式上传进度 ${pct}% (${this.formatSize(offset)}/${this.formatSize(total)})`); } continue; } // 普通单块上传 const ok = await this._putToOssUrl(ossUrl, buf, { "Content-Range": `bytes ${start}-${end}/${total}`, "Content-Length": String(expectedLen), }); if (!ok) { console.warn(`[光鸭秒传] 兜底：第${chunkNo}块 PUT 上传失败`); return false; } offset = end + 1; const pct = Math.floor(offset * 100 / total); if (pct !== lastPct) { lastPct = pct; console.log(`[光鸭秒传] 流式上传进度 ${pct}% (${this.formatSize(offset)}/${this.formatSize(total)})`); } } const cost = ((Date.now() - t0) / 1000).toFixed(1); console.log(`[光鸭秒传] 兜底：流式上传完成 ✓，总耗时 ${cost}s，共 ${chunkNo} 块`); return true; }, /** * 兜底：当秒传未命中、后端一直"文件上传中"时， * 如果是光鸭提取的JSON且文件≤100MB，则直接把文件内容PUT到光鸭返回的OSS端点。 * 光鸭OSS一般为S3兼容；此处尝试极简PUT（无签名头），若后端接受则秒传任务会立刻完成。 * 失败不抛异常，仅返回 true/false。 */ async tryUploadOssDirectPut(wholeFileBuffer, tokenBodyData) { if (!wholeFileBuffer || !tokenBodyData) return false; try { const ep = tokenBodyData.fullEndPoint || ""; const op = tokenBodyData.objectPath || ""; if (!ep || !op) return false; const url = op.startsWith("/") ? `${ep}${op}` : `${ep}/${op}`; console.log(`[光鸭秒传] 兜底：尝试PUT上传到OSS ${url.slice(0, 120)}...`); const u8 = new Uint8Array(wholeFileBuffer); // 先试 fetch（简单PUT，Content-Type application/octet-stream） let respOk = false; try { const r = await fetch(url, { method: "PUT", mode: "cors", credentials: "omit", headers: { "Content-Type": "application/octet-stream" }, body: u8, }); respOk = (r.status >= 200 && r.status < 300); console.log(`[光鸭秒传] OSS PUT fetch 状态=${r.status}，成功=${respOk}`); } catch (fe) { console.warn(`[光鸭秒传] OSS PUT fetch 失败，退回GM：${String(fe?.message||fe).slice(0,120)}`); // 兜底用 GM_xmlhttpRequest try { respOk = await new Promise((resolve) => { GM_xmlhttpRequest({ method: "PUT", url, headers: { "Content-Type": "application/octet-stream" }, data: u8.buffer, onload: (rr) => resolve(rr.status >= 200 && rr.status < 300), onerror: () => resolve(false), ontimeout: () => resolve(false), timeout: 120000, }); }); } catch { respOk = false; } } return respOk; } catch (e) { console.warn(`[光鸭秒传] OSS PUT 异常：${String(e?.message || e).slice(0, 200)}`); return false; } }, formatSize(bytes) { const n = Number(bytes) || 0; if (n < 1024) return `${n} B`; const units = ["KB", "MB", "GB", "TB"]; let value = n / 1024; let i = 0; while (value >= 1024 && i < units.length - 1) { value /= 1024; i++; } return `${value.toFixed(2)} ${units[i]}`; }, normalizeFilePath(path) { const clean = (path || "").replace(/^\/+/, ""); return `/${clean}`; }, normalizeEtag(etag) { return (etag || "").trim(); }, showLoadingDialog(title, msg = "", showProgress = false) { const existing = document.getElementById("guangya-loading-dialog"); if (existing) existing.remove(); const dialog = document.createElement("div"); dialog.id = "guangya-loading-dialog"; const progressHtml = showProgress ? `

准备中... 0%

0 / 0

` : ""; dialog.innerHTML = `

${title}

${msg}

${progressHtml}

`; (document.body || document.documentElement).appendChild(dialog); }, updateLoadingMsg(msg) { const el = document.getElementById("guangya-loading-msg"); if (el) el.textContent = msg; }, /** * 更新进度条 * @param {number} processed - 已处理数 * @param {number} total - 总数 * @param {string} phase - 阶段文本（如"创建目录"、"秒传中"） */ updateLoadingProgress(processed, total, phase = "") { const pctEl = document.getElementById("guangya-loading-percent"); const barEl = document.getElementById("guangya-loading-bar"); const countEl = document.getElementById("guangya-loading-count"); const phaseEl = document.getElementById("guangya-loading-phase"); const nTotal = Math.max(1, Number(total) || 0); const nDone = Math.min(nTotal, Math.max(0, Number(processed) || 0)); const pct = Math.floor((nDone / nTotal) * 100); if (barEl) barEl.style.width = pct + "%"; if (pctEl) pctEl.textContent = pct + "%"; if (countEl) countEl.textContent = `${nDone} / ${nTotal}`; if (phaseEl && phase) phaseEl.textContent = phase; }, closeLoadingDialog() { const el = document.getElementById("guangya-loading-dialog"); if (el) el.remove(); }, showResultDialog(jsonData, shareTitle = "", showSaveBtn = false, baseName = "") { const existing = document.getElementById("guangya-result-dialog"); if (existing) existing.remove(); let currentJson = jsonData; const jsonStr = JSON.stringify(jsonData, null, 2); const checkboxHtml = shareTitle ? `

设置 commonPath 为分享标题：${shareTitle}

` : ""; const saveBtnHtml = showSaveBtn ? ` ` : ""; const dialog = document.createElement("div"); dialog.id = "guangya-result-dialog"; dialog.innerHTML = `

生成JSON成功

${checkboxHtml}

${jsonStr}

${saveBtnHtml}

`; document.body.appendChild(dialog); const getJsonStr = () => JSON.stringify(currentJson, null, 2); if (shareTitle) { const commonPathCb = document.getElementById("guangya-commonpath-checkbox"); if (commonPathCb && "checked" in commonPathCb) { commonPathCb.onchange = () => { currentJson = Object.assign({}, jsonData, { commonPath: commonPathCb.checked ? shareTitle + "/" : "" }); const pre = document.getElementById("guangya-json-preview"); if (pre) pre.textContent = getJsonStr(); }; } } const resultCopyBtn = document.getElementById("guangya-result-copy"); if (resultCopyBtn) { resultCopyBtn.onclick = () => { GM_setClipboard(getJsonStr()); resultCopyBtn.textContent = "已复制"; setTimeout(() => { resultCopyBtn.textContent = "复制"; }, 1500); }; } const resultDlBtn = document.getElementById("guangya-result-download"); if (resultDlBtn) { resultDlBtn.onclick = () => { const text = getJsonStr(); const blob = new Blob([text], { type: "application/json" }); const url = URL.createObjectURL(blob); const a = document.createElement("a"); a.href = url; const tf = currentJson?.totalFiles || currentJson?.totalFilesCount || 0; const ts = currentJson?.totalSize || 0; a.download = makeRapidTransferExportFilename(baseName, tf, ts); a.click(); URL.revokeObjectURL(url); }; } const resultSaveBtn = document.getElementById("guangya-result-save"); if (resultSaveBtn) { resultSaveBtn.onclick = async () => { try { resultSaveBtn.textContent = "保存中..."; resultSaveBtn.disabled = true; // -------------------- 检查是否有未完成进度，询问是否续跑 -------------------- let useResume = false; let savedProgress = null; try { const rawProg = GM_getValue(KEY_GUANGYA_SAVE_PROGRESS, ""); if (rawProg && typeof rawProg === "string" && rawProg.trim()) { savedProgress = JSON.parse(rawProg); } } catch { savedProgress = null; } const hasPending = savedProgress && savedProgress.phase !== "done" && savedProgress.totalFiles && (Date.now() - (savedProgress.updatedAt || 0) < 1000 * 60 * 60 * 24); // 24 小时内算有效 if (hasPending) { const totalN = Number(savedProgress.totalFiles) || 0; const probeDone = Math.min(totalN, (Number(savedProgress.probeIndex) || 0) + (Number(savedProgress.mkdirIndex) || 0)); // 读取已成功数量 let doneN = 0; try { const arr = GM_getValue(KEY_GUANGYA_SAVE_SUCCESS_SET, "[]"); doneN = Array.isArray(arr) ? arr.length : (JSON.parse(String(arr)) || []).length; } catch { /* ignore */ } const pct = totalN > 0 ? Math.floor((doneN / totalN) * 100) : 0; const phaseText = savedProgress.phase === "mkdir" ? "创建目录阶段" : savedProgress.phase === "probe" ? "秒传阶段" : savedProgress.phase === "error" ? "出错中断" : "进行中"; const resumeChoice = confirm( `检测到上次未完成的秒传任务：\n\n` + `状态：${phaseText}\n` + `总数：${totalN} 条\n` + `已成功：${doneN} 条（${pct}%）\n` + `目标目录：${savedProgress.targetDirName || "(未知)"}\n\n` + `是否续跑？（续跑会跳过已成功的 ${doneN} 条，只处理剩余文件）\n\n` + `点击「确定」= 续跑\n` + `点击「取消」= 从头开始，放弃上次进度` ); useResume = !!resumeChoice; if (!useResume) { // 清理旧进度 try { GM_setValue(KEY_GUANGYA_SAVE_PROGRESS, ""); } catch { /* ignore */ } try { GM_setValue(KEY_GUANGYA_SAVE_SUCCESS_SET, "[]"); } catch { /* ignore */ } } } await panGuangya.saveToRecorded(currentJson, { isResume: useResume }); } catch (e) { alert("保存失败：" + (e?.message || e)); } finally { resultSaveBtn.textContent = "保存"; resultSaveBtn.disabled = false; } }; } const resultCloseBtn = document.getElementById("guangya-result-close"); if (resultCloseBtn) resultCloseBtn.onclick = () => dialog.remove(); }, /** * 把 files 数组转成可分享的秒传 JSON。 * 第 2 个可选参数 sourceTag： * · 传 "guangya" → 每行写入 sourceGuangya:true（导入端判定为光鸭源，用 fileId 调 get_res_download_url） * · 传 "xunlei" → 每行写入 sourceXunlei:true（导入端判定为迅雷源，用 shareId/passCodeToken 调迅雷 getFileDetail 补 downloadUrl） * · 不传 / null → 不注入任何来源标记（老代码默认行为，兼容） * 第 3 个可选参数 extraRowProps：对象，会浅拷贝写入每行（如迅雷分享页会传 {shareId, passCodeToken}，导入端可现场补 downloadUrl） */ makeJson(files, sourceTag = null, extraRowProps = null) { const tagGuangya = String(sourceTag || "").toLowerCase() === "guangya"; const tagXunlei = String(sourceTag || "").toLowerCase() === "xunlei"; const extras = extraRowProps && typeof extraRowProps === "object" ? extraRowProps : null; const normalized = files .filter((f) => f && f.path) .map((f) => { const path = this.normalizeFilePath(f.path); const size = String(f.size ?? 0); const gcid = this.normalizeEtag(f.gcid || ""); const etag = this.normalizeEtag(f.etag || ""); const md5 = this.normalizeEtag(f.md5 || ""); const fileId = String(f.fileId ?? "").trim(); const cid = String(f.cid ?? "").trim(); const wholeCid = String(f.wholeCid ?? "").trim(); const tripleCid = String(f.tripleCid ?? "").trim(); const parentId = String(f.parentId ?? "").trim(); // 清理 downloadUrl：去除首尾空白、反引号、引号等包裹字符（迅雷 API 偶尔返回被包裹的 URL） const downloadUrl = String(f.downloadUrl ?? "").trim().replace(/^[\s`"'']+|[\s`"'']+$/g, ""); const entry = { size, path }; if (gcid) entry.gcid = gcid; if (etag) entry.etag = etag; if (md5) entry.md5 = md5; if (fileId) entry.fileId = fileId; // cid 三兄弟显式写入（tripleCid / wholeCid / cid 分别对应 3×20KB 采样 / 整文件 SHA-1 / 兼容老脚本） // 导入端 isValidCidFromJson 能直接命中，跳过 helper 下载 Range 计算 entry.cid = cid; if (tripleCid) entry.tripleCid = tripleCid; if (wholeCid) entry.wholeCid = wholeCid; entry.parentId = parentId; entry.downloadUrl = downloadUrl; // 显式标记来源（仅当调用方指定时；光鸭/迅雷各自调用时传对应的 tag，避免互相污染） if (tagGuangya) entry.sourceGuangya = true; if (tagXunlei) entry.sourceXunlei = true; // 附加行级属性（如迅雷分享页的 shareId + passCodeToken，导入端可现场调迅雷 getFileDetail 补 cid） if (extras) { for (const k of Object.keys(extras)) { if (extras[k] !== undefined && extras[k] !== null && extras[k] !== "") { entry[k] = extras[k]; } } } return entry; }); const totalSize = normalized.reduce((sum, f) => sum + (Number(f.size) || 0), 0); const result = { scriptVersion: SCRIPT_VERSION, scriptAuthor: "sumuve", totalFilesCount: normalized.length, totalSize, formattedTotalSize: this.formatSize(totalSize), files: normalized, }; // 🔴 关键：把 sourceTag / shareId / passCodeToken 也写在【顶层JSON】， // 导入端能一次性从 obj.shareId / obj.sourceTag 拿到（即使是旧脚本提取的老 JSON， // 行级可能没写，但顶层有也能用）。 if (tagXunlei) result.sourceTag = "xunlei"; if (tagGuangya) result.sourceTag = "guangya"; if (extras) { for (const k of Object.keys(extras)) { if (extras[k] !== undefined && extras[k] !== null && extras[k] !== "") { // 行级已经写过，顶层再复制一份（同名属性不会冲突，行级优先级 > 顶层） if (typeof result[k] === "undefined") result[k] = extras[k]; } } } return result; }, }; // ============================================================ // 迅雷云盘：token 拦截 + 文件列表 + 秒传 JSON 提取 // ============================================================ // 🛡️ 图片 CDN URL 识别：迅雷 API 偶尔会把 backstage-img / 88cdn 这类图片资源 CDN // 链接混进 links/web_content_link 字段（特别是分享页 detail 接口）， // 这些 URL 不能用于文件下载，更不能拿去 Range 取样算 cid（取回来全是 JPG/PNG 二进制）。 // 统一在这里拦截，提取端 + 导入端都引用同一个判定函数，避免逻辑分叉。 const IMAGE_CDN_PATTERNS = [ /88cdn\.com/i, // 迅雷后端图片资源 CDN（backstage-img-ssl.a.88cdn.com 等） /backstage-img/i, // backstage-img / backstage-img-ssl 域名段 /\/thumbnail\//i, // 缩略图路径 /(?:^|[?&])thumb=/i, // 缩略图参数 /\.(?:jpg|jpeg|png|gif|webp|bmp|ico)(?:\?|$)/i, // 图片扩展名结尾 ]; function isImageCdnUrl(url) { if (!url || typeof url !== "string") return false; // 先做与 cleanRowDlUrl 一致的清洗：去除首尾反引号/引号/空白 const s = String(url).trim().replace(/^[\s`"'']+|[\s`"'']+$/g, ""); if (!s || !/^https?:\/\//i.test(s)) return false; for (const re of IMAGE_CDN_PATTERNS) { if (re.test(s)) return true; } return false; } const panXunlei = { isHost() { return location.hostname === "pan.xunlei.com"; }, _cachedToken: "", _cachedDeviceId: "", _cachedCaptchaToken: "", _cachedClientId: "", /** * 统一抽取迅雷文件对象的 9 个字段（基于 2026-08-02 真实抓包写死字段优先级）： * path / fileId / parentId / size / gcid / md5 / etag / cid / downloadUrl * * 【真实迅雷 drive/v1 接口实际字段名（已实测 reqid=310 列表 + reqid=315 详情）】 * fileId ← f.id （官方名：id） * parentId ← f.parent_id （官方名：parent_id） * gcid ← f.hash （官方名：hash，40位大写hex） * md5 ← f.md5_checksum （官方名：md5_checksum，32位hex；若为apk则常为空，list/detail 目前示例里都为空） * downloadUrl← f.web_content_link OR f.links["application/octet-stream"].url （官方名：详情接口才返回） * cid ← 官方响应里【不存在】此字段；由 enrichEntriesMissingHashes 阶段用下载链接的 Range 样本计算 * * 以下字段兼容列表仅作兜底（保留历史/非标准响应兼容性），优先级永远低于上面官方字段： * md5 兼容：etag(32位) / md5sum / hash_md5 / file_md5 / contentMd5 ... * cid 兼容（兜底，几乎不会命中）：cid / sampleCid / chunkCid / samplingCid / sampleHash / triple_cid ... */ _normalizeFileEntry(f, filePath, parentIdFallback = "") { // 1) 官方字段优先，保证 1:1 匹配真实 API 返回 const id = String(f.id ?? f.fileId ?? f.file_id ?? "").trim(); const parent = String(f.parent_id ?? f.parentId ?? parentIdFallback ?? "").trim(); const sizeNum = Number(f.size ?? f.fileSize ?? f.file_size ?? f.length ?? f.file_length ?? 0) || 0; // gcid：真实字段名可能是 hash / gcid / sha1 / fileHash / contentHash / merkleRoot 等 const gcidRaw = (f.hash ?? f.gcid ?? f.sha1 ?? f.SHA1 ?? f.fileHash ?? f.file_hash ?? f.contentHash ?? f.content_hash ?? f.merkleRoot ?? f.merkle_root ?? f.merkle_hash ?? f.blockHash ?? f.block_hash ?? ""); const gcid = String(gcidRaw).trim(); // md5：官方字段 f.md5_checksum 排第一（实测 list/detail 都可能返回空字符串） const md5Candidates = [ f.md5_checksum, f.md5Checksum, f.md5_checkSum, f.md5, f.etag, f.md5sum, f.md5Sum, f.hash_md5, f.md5Hash, f.file_md5, f.contentMd5, f.content_md5, f.md5_base64, f.etagMd5, ]; let md5 = ""; for (const v of md5Candidates) { const s = String(v || "").trim().toLowerCase().replace(/^"|"$/g, ""); if (/^[0-9a-f]{32}$/.test(s)) { md5 = s; break; } } const etag = String(f.etag ?? "").trim(); // cid：真实迅雷 API 里没有此字段。兼容层仅作为兜底（极少场景才会命中） const rawCid = (f.cid ?? f.sampleCid ?? f.chunkCid ?? f.samplingCid ?? f.sampleHash ?? f.fileSample ?? f.blockSampleHash ?? f.chunkSample ?? f.cidStr ?? f.file_cid ?? f.sample_cid ?? f.triple_cid ?? ""); const cleanCid = String(rawCid || "").trim(); const validCid = /^[0-9A-Fa-f]{40}$/.test(cleanCid) ? cleanCid : ""; // downloadUrl：官方 2 处来源（详情接口），其他字段名仅兜底 let downloadUrl = ""; const linkObj = f.links && typeof f.links === "object" && !Array.isArray(f.links) ? (f.links["application/octet-stream"] || f.links["*/*"] || f.links.default // 🔑 兜底：标准 MIME key 不匹配时，遍历所有 key 取首个含 .url 的 || Object.values(f.links).find(v => v && typeof v === "object" && typeof v.url === "string" && v.url) || null) : null; const dlCandidates = [ linkObj && linkObj.url, f.web_content_link, f.webContentLink, f.downloadUrl, f.download_url, f.url, f.mediaUrl, f.media_url, f.downloadLink, f.download_link, ]; for (const v of dlCandidates) { const s = String(v || "").trim(); if (/^https?:\/\//i.test(s) && !isImageCdnUrl(s)) { downloadUrl = s; break; } } return { path: filePath, fileId: id, parentId: parent, size: sizeNum, gcid, md5, etag, cid: validCid, downloadUrl, }; }, /** * 🛡️ 从 detail API 返回的原始对象里兜底扫下载链接（嵌套对象扁平扫描） * 【问题背景】迅雷 detail / share/detail 接口返回结构偶尔把 web_content_link / links 藏在 * 多层嵌套字段（而非标准 web_content_link / links["application/octet-stream"].url）， * 这时 _normalizeFileEntry 会漏掉。_normalizeFileEntry 返回空 downloadUrl 时调用本函数兜底。 * 【过滤规则】 * · 字段名匹配 thumbnail / thumb_ / _thumb 的直接跳过（避免把 backstage-img / 88cdn 图片CDN收进来） * · isImageCdnUrl 命中的 URL 一律排除（避免把图片链接当文件下载链接） * 【优先顺序】vod | lixian | cdn | download | pan.xunlei | api-pan 域名段优先，否则取首个合格URL * @param {any} detailObj getFileDetail 返回的原始 JSON 对象（任意层级嵌套） * @returns {string} 找到的下载链接字符串，找不到返回 "" */ _extractDlFromDetailFlat(detailObj) { if (!detailObj || typeof detailObj !== "object") return ""; const flatScan = []; const collect = (obj) => { if (!obj || typeof obj !== "object") return; if (Array.isArray(obj)) { for (const x of obj) collect(x); return; } for (const k of Object.keys(obj)) { const v = obj[k]; if (typeof v === "string" && /^https?:\/\//i.test(v)) { // 排除图片 CDN / 缩略图字段 if (/thumbnail|thumb_|_thumb/i.test(k)) continue; if (isImageCdnUrl(v)) continue; flatScan.push(v); } else if (typeof v === "object") { collect(v); } } }; collect(detailObj); if (!flatScan.length) return ""; const preferHosts = /vod|lixian|cdn|download|pan\.xunlei|api-pan/i; return flatScan.find(u => preferHosts.test(u)) || flatScan[0] || ""; }, /** * 🔑 通过下载链接计算 tripleCid / wholeCid（sample 兜底） * 当迅雷 list/detail/share/detail 都不再返回 hash/gcid 时，只能用下载链接下载 3×20KB 样本 * 计算标准迅雷 cid，并把 tripleCid 当作 gcid 使用。 * 返回 { gcid(=tripleCid), tripleCid, wholeCid, downloadUrl } */ async computeCidFromDownloadUrl(downloadUrl, fileSize) { const SAMPLE = 20 * 1024; const WHOLE_FILE_MAX = 100 * 1024 * 1024; const dlSrc = typeof downloadUrl === "object" ? downloadUrl?.url : downloadUrl; const size = Number(fileSize) || 0; if (!dlSrc || !size) { console.warn("[迅雷提取 computeCidFromDownloadUrl] ❌ 缺少 downloadUrl 或 size"); return { gcid: "", tripleCid: "", wholeCid: "" }; } console.log(`[迅雷提取 computeCidFromDownloadUrl] 📡 开始计算 cid：size=${size} url=${String(dlSrc).slice(0, 60)}…`); let wholeFileBuffer = null; if (size <= WHOLE_FILE_MAX) { // 迅雷 CDN 需要 Referer，优先用 GM_xmlhttpRequest（可跨域且能自定义 Referer） wholeFileBuffer = await new Promise(resolve => { GM_xmlhttpRequest({ method: "GET", url: dlSrc, headers: { "Referer": "https://pan.xunlei.com/", "Origin": "https://pan.xunlei.com/" }, responseType: "arraybuffer", onload: (r) => resolve((r.status === 200 || r.status === 206) ? r.response : null), onerror: () => resolve(null), ontimeout: () => resolve(null), timeout: 120000, }); }); // GM_xhr 失败再试 fetch（部分环境可能 fetch 更稳） if (!wholeFileBuffer) { try { const r = await fetch(dlSrc, { method: "GET", mode: "cors", credentials: "omit" }); if (r && (r.status === 200 || r.status === 206)) wholeFileBuffer = await r.arrayBuffer(); } catch {} } } let combinedBuffer = null; if (wholeFileBuffer) { const u8 = new Uint8Array(wholeFileBuffer); const picks = []; if (size <= SAMPLE) picks.push(u8.slice(0, size), u8.slice(0, size), u8.slice(0, size)); else if (size <= SAMPLE * 2) { picks.push(u8.slice(0, SAMPLE)); const m = Math.floor(size / 3); picks.push(u8.slice(m, Math.min(m + SAMPLE, size))); picks.push(u8.slice(Math.max(0, size - SAMPLE), size)); } else { picks.push(u8.slice(0, SAMPLE)); const m = Math.floor(size / 3); picks.push(u8.slice(m, m + SAMPLE)); picks.push(u8.slice(size - SAMPLE, size)); } const total = picks.reduce((s, p) => s + p.length, 0); const cmb = new Uint8Array(total); let off = 0; for (const p of picks) { cmb.set(p, off); off += p.length; } combinedBuffer = cmb.buffer; } else { const downloadByte = (s, e) => panGuangya._downloadByteRange(dlSrc, s, e); const ranges = [ { start: 0, end: SAMPLE - 1 }, { start: Math.floor(size / 3), end: Math.min(Math.floor(size / 3) + SAMPLE - 1, size - 1) }, { start: Math.max(0, size - SAMPLE), end: size - 1 }, ]; const bufs = []; for (const rr of ranges) { const ab = await downloadByte(rr.start, rr.end); if (ab && ab.byteLength > 0) bufs.push(ab); } if (bufs.length < 2) { console.warn("[迅雷提取 computeCidFromDownloadUrl] ❌ Range 样本下载不足，无法计算 cid"); return { gcid: "", tripleCid: "", wholeCid: "" }; } const total = bufs.reduce((s, b) => s + (b.byteLength || 0), 0); const cmb = new Uint8Array(total); let off = 0; for (const b of bufs) { cmb.set(new Uint8Array(b), off); off += b.byteLength; } combinedBuffer = cmb.buffer; } const res = await panGuangya.computeCidFromArrayBuffer(combinedBuffer, size); const wholeCid = wholeFileBuffer ? await panGuangya.sha1Whole(wholeFileBuffer).catch(() => (res ? res.wholeCid : "")) : (res ? res.wholeCid : ""); const tripleCid = res ? res.tripleCid : ""; console.log(`[迅雷提取 computeCidFromDownloadUrl] ✅ tripleCid=${tripleCid ? "有" : "无"} wholeCid=${wholeCid ? "有" : "无"} 方式=${wholeFileBuffer ? "整文件" : "Range样本"}`); return { gcid: tripleCid, tripleCid, wholeCid: wholeCid || (res ? res.wholeCid : ""), downloadUrl: dlSrc, }; }, /** * 取单个文件详情：补全 list 接口不给的 cid、md5、downloadUrl * 【支持两种上下文】 * · 登录态主站：shareId/passCodeToken 留空即可，走 drive/v1/files/{id} * · 分享页（最常见失败点）：传入 shareId + passCodeToken，内部会尝试 4 条路径按顺序取： * 1) drive/v1/share/detail?share_id=...&pass_code_token=...&parent_id=&usage=CONSUME → 从 files[] 里按 id 抓 * 2) drive/v1/share/detail?share_id=...&pass_code_token=...&file_id=&usage=CONSUME → 兼容方案 * 3) drive/v1/share/link 专门生成分享文件下载链接的 endpoint（兜底） * 4) drive/v1/files/{id}?space=&usage=CONSUME → 带 shareId / passCodeToken 拼 query 匿名访问兜底 */ async getFileDetail(id, shareId = "", passCodeToken = "", extraCtx = null) { if (!id) return null; const fileIdStr = String(id); const parentIdHint = String((extraCtx && extraCtx.parentId) || ""); const authHeaders = this.getAuthHeaders() || {}; const consoleTag = "[迅雷提取 getFileDetail]"; // 🔑 修复：savedHit 声明移到函数开头，避免路径4/5访问时报 "savedHit is not defined" let savedHit = null; // ------- 尝试 1：分享页上下文优先 —— 用“该文件所在目录”调 share/detail， // 这样返回的 files[] 里天然包含该文件（迅雷 Web 端实际就是这样拿下载链接） const _selfDetail = this; // 🔑 辅助：创建【匿名鉴权头】（分享页专用）—— // 迅雷分享接口匿名可访问（靠 pass_code_token 鉴权），但把自己的 Bearer 用户 token 传进去， // 后端会校验「分享 owner == 当前用户」，不是自己的分享就直接 401/403，永远拿不到 downloadUrl。 // 但是！x-captcha-token 是【反验证码令牌】（不是用户鉴权），所有接口（包括匿名分享接口）都要求， // 缺了会直接 400 "captcha_token is empty" —— 所以必须保留。 // 🔑 关键：captcha_token 从 _getPersistentCaptchaToken() 读取（跨页面持久化）， // 用户先在 pan.xunlei.com 访问分享页时拦截器会捕获并持久化到 GM_setValue。 const _makeAnonymousHeaders = () => { const cloned = {}; // 1) 先拷贝「非鉴权」头（Content-Type / x-client-id / Referer / 全部 device* / captcha*） const safeKeys = ["content-type","x-client-id","referer","x-device-id","X-Device-Id","x-guid","X-Guid","x-captcha-token","x-Captcha-Token","x-captcha","captcha-token"]; if (authHeaders && typeof authHeaders === "object") { for (const k of Object.keys(authHeaders)) { if (safeKeys.includes(k) || /device|guid|client|captcha/i.test(k)) cloned[k] = authHeaders[k]; } } // 2) 如果 authHeaders 里没 device*（极端情况），再兜底跑 helper._ensureStableDeviceId() 补一次 const hasDid = cloned["x-device-id"] || cloned["X-Device-Id"] || cloned["x-guid"] || cloned["X-Guid"]; if (!hasDid && typeof helper === "object" && helper && typeof helper._ensureStableDeviceId === "function") { try { const d = helper._ensureStableDeviceId(); if (d) { cloned["x-device-id"] = d; cloned["X-Device-Id"] = d; cloned["x-guid"] = d; cloned["X-Guid"] = d; } } catch {} } // 3) captcha_token 兜底：从 authHeaders 没拷到 → 从 panXunlei 持久化存储读取（跨页面） if (!cloned["x-captcha-token"] && !cloned["x-captcha"]) { const ct = _selfDetail._getPersistentCaptchaToken ? _selfDetail._getPersistentCaptchaToken() : ""; if (ct) { cloned["x-captcha-token"] = ct; } } if (!cloned["x-client-id"]) cloned["x-client-id"] = this._cachedClientId || XUNLEI_CLIENT_ID; if (!cloned["Content-Type"] && !cloned["content-type"]) cloned["Content-Type"] = "application/json"; if (!cloned["Referer"] && !cloned["referer"]) cloned["Referer"] = "https://pan.xunlei.com/"; return cloned; }; // 辅助：在返回 hit 之前，用 flat scan 兜底把缺失的 web_content_link / links 注入进去 // （这样所有 getFileDetail 调用方：enrichEntriesMissingHashes / 导入端3fallback / 终极fallback 都自动受益， // 不需要在每个调用点再重复 flat scan 兜底） const _polishHitBeforeReturn = (hit) => { if (!hit || typeof hit !== "object") return hit; try { // 先取 _normalizeFileEntry 已经能识别到的 URL const n = _selfDetail._normalizeFileEntry ? _selfDetail._normalizeFileEntry(hit, "", "") : null; const normDl = (n && n.downloadUrl && !isImageCdnUrl(n.downloadUrl)) ? n.downloadUrl : ""; if (normDl) return hit; // 已有官方下载链接，直接返回 // 官方命名字段没命中，跑 flat scan 找嵌套 URL const extra = _selfDetail._extractDlFromDetailFlat ? _selfDetail._extractDlFromDetailFlat(hit) : ""; if (!extra) { console.warn(`${consoleTag} ⚠️ _polishHitBeforeReturn: flat scan 也未找到下载链接！hit 字段: ${Object.keys(hit).join(",")}`); return hit; // 也没找到就原样返回 } // 找到就写入迅雷官方命名的字段，后续所有 _normalizeFileEntry 都能识别 console.log(`${consoleTag} 🛡️ 返回前注入 flat scan 兜底下载链接 → ${String(extra).slice(0, 70)}…`); if (!hit.web_content_link) { try { hit.web_content_link = extra; } catch {} } if (!hit.links) { try { hit.links = {}; } catch {} } try { if (hit.links && typeof hit.links === "object" && !hit.links["application/octet-stream"]) { hit.links["application/octet-stream"] = { url: extra }; } } catch {} } catch {} return hit; }; if (shareId && passCodeToken) { // 🔑 分享页路径 1/2/3：强制用匿名鉴权头（否则「不是自己的分享」会被后端鉴权层 401/403 打回） const anon = _makeAnonymousHeaders(); const hasCaptcha = !!(anon["x-captcha-token"] || anon["x-captcha"]); const hasDevice = !!(anon["x-device-id"] || anon["X-Device-Id"]); console.log(`${consoleTag} 🔍 开始以【匿名头】访问分享接口（shareId=${String(shareId).slice(0,16)}… captchaToken=${hasCaptcha ? "有" : "❌无"} deviceId=${hasDevice ? "有" : "❌无"} parentId=${parentIdHint ? parentIdHint.slice(0,16)+"…" : "(空)"}）`); if (!hasCaptcha) { console.warn(`${consoleTag} ❌【关键】captcha_token 不可用！迅雷 API 会返回 400 captcha_invalid。`); console.warn(`${consoleTag} 💡 解决方案：请先在浏览器中打开迅雷分享页（https://pan.xunlei.com/s/${encodeURIComponent(shareId)}），等页面加载完成后，脚本会自动捕获 captcha_token 并持久化。然后回到光鸭页面重新导入 JSON 即可。`); console.warn(`${consoleTag} 💡 或者：在迅雷网盘页面（pan.xunlei.com）任意浏览一下，也能捕获到 captcha_token。`); } // 辅助：在 share/detail 响应中查找目标文件 const _findInResp = (j) => { if (!j) return null; const list = Array.isArray(j.files) ? j.files : []; const hit = list.find(x => String(x.id) === fileIdStr) || (String(j.id) === fileIdStr ? j : null); if (!hit && list.length > 0) { console.log(`${consoleTag} 📋 响应 files[0] 字段:`, Object.keys(list[0]).join(","), `hash=${list[0].hash || "❌"} web_content_link=${list[0].web_content_link ? "有" : "❌"} links=${list[0].links ? Object.keys(list[0].links).join(",") : "❌"}`); } return hit; }; // 🔑 2026-08 性能优化（重大）：分享页场景下路径1/1b/3 全部无效（list 接口已不返回 hash，路径3全404） // 直接调 _fetchFileHash（路径2），从 7 次请求/文件降到 1 次请求/文件 // 实测 23 个文件：原 ~7×23=161 次 API 请求 → 优化后 1×23=23 次请求 try { console.log(`${consoleTag} 🚀 分享页快速通道：直接调 _fetchFileHash（跳过路径1/1b/3）`); const hashInfo = await _selfDetail._fetchFileHash(fileIdStr, shareId, passCodeToken); if (hashInfo && hashInfo.gcid) { // 构造一个最小的 hit 对象返回 const fastHit = { id: fileIdStr, kind: "drive#file", name: "", parent_id: parentIdHint, hash: hashInfo.gcid, gcid: hashInfo.gcid, size: hashInfo.size || 0, md5_checksum: hashInfo.md5 || "", links: hashInfo.downloadUrl ? { "application/octet-stream": { url: hashInfo.downloadUrl } } : {}, web_content_link: hashInfo.downloadUrl || "", }; console.log(`${consoleTag} ✅ 快速通道命中 gcid=${hashInfo.gcid.slice(0, 16)}… size=${hashInfo.size || "❌"}`); return _polishHitBeforeReturn(fastHit); } console.warn(`${consoleTag} ⚠️ 快速通道未命中，降级到路径1/3/4/5`); } catch (errFast) { console.warn(`${consoleTag} ⚠️ 快速通道异常: ${String(errFast?.message || errFast).slice(0, 200)}，降级到路径1/3/4/5`); } // ------- 路径 1：用 parentIdHint 调 share/detail（文件所在目录） // 🔑 Bug 修复：原来 parent_id 硬编码为空字符串，文件在子目录时永远找不到 // 🔑 修复：先试不带 with_audit（可能返回 hash），再试带 with_audit=true try { const u = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=${encodeURIComponent(parentIdHint)}&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=200&with_audit=true&thumbnail_size=SIZE_LARGE&usage=CONSUME`; const t = await helper.get(u, anon); const j = JSON.parse(t || "null"); const hit = _findInResp(j); if (hit) { const hasHash = /^[0-9A-Fa-f]{40}$/.test(String(hit.hash || hit.gcid || "")); // 🔑 详细日志：打印 hit 的下载相关字段，方便定位提取失败 const linksKeys = hit.links && typeof hit.links === "object" ? Object.keys(hit.links) : []; const wcl = String(hit.web_content_link || "").slice(0, 80); console.log(`${consoleTag} 📋 路径1 hit 下载字段: links={${linksKeys.join(",")}} web_content_link=${wcl || "❌"} hash=${hit.hash || "❌"} size=${hit.size || "❌"}`); // 🔑 先 polish（可能通过 flat scan 注入下载链接） const polished = _polishHitBeforeReturn(hit); // 🔑 检查 polish 后是否真的能提取到 downloadUrl const normCheck = _selfDetail._normalizeFileEntry ? _selfDetail._normalizeFileEntry(polished, "", "") : null; const dlExtractable = !!(normCheck && normCheck.downloadUrl); if (hasHash || dlExtractable) { console.log(`${consoleTag} ✅ 路径1命中（parent_id=${parentIdHint ? "有" : "根"}）→ hasHash=${hasHash} dlExtractable=${dlExtractable}`); return polished; } // 无 hash 且无法提取 downloadUrl → 保存 hit，继续 Path 3 POST 获取下载链接 savedHit = polished; console.warn(`${consoleTag} ⚠️ 路径1命中但无法提取 downloadUrl（links可能为空对象），保存 hit 继续尝试 Path 3`); } else { console.warn(`${consoleTag} ⚠️ 路径1: 文件未在 parent_id=${parentIdHint ? "子目录" : "根目录"} 中找到`); } // 🔑 第二次尝试：不带 with_audit（with_audit 可能导致 hash 被脱敏） if (hit && !savedHit?.hash) { try { const u2 = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=${encodeURIComponent(parentIdHint)}&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=200&with_audit=false&usage=CONSUME`; const t2 = await helper.get(u2, anon); const j2 = JSON.parse(t2 || "null"); const hit2 = _findInResp(j2); if (hit2) { const hasHash2 = /^[0-9A-Fa-f]{40}$/.test(String(hit2.hash || hit2.gcid || "")); const linksKeys2 = hit2.links && typeof hit2.links === "object" ? Object.keys(hit2.links) : []; const wcl2 = String(hit2.web_content_link || "").slice(0, 80); console.log(`${consoleTag} 📋 路径1(无audit) hit: links={${linksKeys2.join(",")}} web_content_link=${wcl2 || "❌"} hash=${hit2.hash || "❌"} size=${hit2.size || "❌"}`); if (hasHash2) { console.log(`${consoleTag} ✅ 路径1(无audit) 命中 hash！`); return _polishHitBeforeReturn(hit2); } const polished2 = _polishHitBeforeReturn(hit2); const normCheck2 = _selfDetail._normalizeFileEntry ? _selfDetail._normalizeFileEntry(polished2, "", "") : null; if (normCheck2 && normCheck2.downloadUrl) { console.log(`${consoleTag} ✅ 路径1(无audit) 命中 downloadUrl！`); return polished2; } // 更新 savedHit 为信息更全的版本 if (!savedHit) savedHit = polished2; } } catch (err1b2) { console.warn(`${consoleTag} ⚠️ 路径1(无audit) 异常: ${String(err1b2?.message || err1b2).slice(0, 200)}`); } } } catch (err1) { console.warn(`${consoleTag} ⚠️ 路径1异常: ${String(err1?.message || err1).slice(0, 240)}`); } // ------- 路径 1b：parentIdHint 为空且文件不在根目录 → 递归搜索子目录 if (!parentIdHint && !savedHit) { try { const rootUrl = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=100&with_audit=true&usage=CONSUME`; const rootResp = await helper.get(rootUrl, anon); const rootJson = JSON.parse(rootResp || "null"); const rootFolders = (rootJson?.files || []).filter(f => f.kind === "drive#folder"); console.log(`${consoleTag} 🔍 路径1b: 根目录有 ${rootFolders.length} 个子文件夹，逐个搜索…`); for (const rf of rootFolders) { try { const subUrl = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=${encodeURIComponent(rf.id)}&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=100&with_audit=true&usage=CONSUME`; const subResp = await helper.get(subUrl, anon); const subJson = JSON.parse(subResp || "null"); const subHit = _findInResp(subJson); if (subHit) { const hasHash = /^[0-9A-Fa-f]{40}$/.test(String(subHit.hash || subHit.gcid || "")); const polished = _polishHitBeforeReturn(subHit); const normCheck = _selfDetail._normalizeFileEntry ? _selfDetail._normalizeFileEntry(polished, "", "") : null; const dlExtractable = !!(normCheck && normCheck.downloadUrl); if (hasHash || dlExtractable) { console.log(`${consoleTag} ✅ 路径1b命中（子目录=${rf.name}）→ hasHash=${hasHash} dlExtractable=${dlExtractable}`); return polished; } savedHit = polished; console.warn(`${consoleTag} ⚠️ 路径1b命中（子目录=${rf.name}）但无法提取 downloadUrl`); break; } } catch {} } } catch (err1b) { console.warn(`${consoleTag} ⚠️ 路径1b异常: ${String(err1b?.message || err1b).slice(0, 200)}`); } } // ------- 路径 3：POST 下载链接端点 // 🔑 Bug 修复：旧 GET 端点已全部 404，改用 POST if (savedHit || !parentIdHint) { const postCandidates = [ { url: `${XUNLEI_API_BASE}/drive/v1/share/download`, body: { share_id: shareId, file_ids: [fileIdStr], pass_code_token: passCodeToken } }, { url: `${XUNLEI_API_BASE}/drive/v1/share/${encodeURIComponent(shareId)}/download`, body: { file_ids: [fileIdStr], pass_code_token: passCodeToken } }, { url: `${XUNLEI_API_BASE}/drive/v1/share/files/download`, body: { share_id: shareId, file_id: fileIdStr, pass_code_token: passCodeToken } }, { url: `${XUNLEI_API_BASE}/drive/v1/share/file/download`, body: { share_id: shareId, file_id: fileIdStr, pass_code_token: passCodeToken } }, ]; for (let pi = 0; pi < postCandidates.length; pi++) { try { const respInfo = await new Promise((resolve) => { GM_xmlhttpRequest({ method: "POST", url: postCandidates[pi].url, headers: { ...anon, "Content-Type": "application/json" }, data: JSON.stringify(postCandidates[pi].body), timeout: 15000, onload: (r) => resolve({ status: r.status, text: r.responseText || "" }), onerror: () => resolve({ status: 0, text: "" }), ontimeout: () => resolve({ status: 0, text: "" }), }); }); if (respInfo.status >= 200 && respInfo.status < 300 && respInfo.text) { const j = JSON.parse(respInfo.text); const flat = _selfDetail._extractDlFromDetailFlat ? _selfDetail._extractDlFromDetailFlat(j) : ""; if (flat) { const fakeHit = savedHit || { id: fileIdStr, kind: "drive#file", name: "" }; fakeHit.web_content_link = flat; if (!fakeHit.links) fakeHit.links = {}; fakeHit.links["application/octet-stream"] = { url: flat }; console.log(`${consoleTag} ✅ 路径3命中（POST候选${pi+1}）→ url=${String(flat).slice(0, 70)}…`); return _polishHitBeforeReturn(fakeHit); } console.warn(`${consoleTag} ⚠️ 路径3候选${pi+1}: 2xx 但无下载链接 resp=${respInfo.text.slice(0,200)}`); } else if (respInfo.status > 0) { console.warn(`${consoleTag} ⚠️ 路径3候选${pi+1}: HTTP ${respInfo.status} resp=${respInfo.text.slice(0,200)}`); } } catch (err3) { console.warn(`${consoleTag} ⚠️ 路径3候选${pi+1}异常: ${String(err3?.message || err3).slice(0, 200)}`); } } } // ------- 🔑 修复：不提前返回 savedHit，继续尝试 Path 4 和 Path 5 // 原来直接 return savedHit 导致 Path 4 (drive/v1/files/{id}) 从未被尝试 if (savedHit) { console.log(`${consoleTag} ⚠️ savedHit 无 hash/downloadUrl，继续尝试 Path 4/5（不再提前返回）`); } else { console.warn(`${consoleTag} ⚠️ 分享页路径1/1b/3 全部未命中 → 尝试路径4（drive/v1/files/{id}）`); } // ------- 🔑 路径2（2026-08 新增）：_fetchFileHash 调 share/file_info 接口单独补 hash(gcid) // 新版迅雷把 share/detail 的 hash 字段隐藏了，但 file_info 接口仍返回 if (!savedHit || !/^[0-9A-Fa-f]{40}$/.test(String(savedHit.hash || savedHit.gcid || ""))) { try { console.log(`${consoleTag} 🧭 路径2：调用 _fetchFileHash 补 hash(gcid)...`); const hashInfo = await _selfDetail._fetchFileHash(fileIdStr, shareId, passCodeToken); if (hashInfo && (hashInfo.gcid || hashInfo.downloadUrl)) { const targetHit = savedHit || { id: fileIdStr, kind: "drive#file", name: "", parent_id: parentIdHint }; if (hashInfo.gcid && !/^[0-9A-Fa-f]{40}$/.test(String(targetHit.hash || targetHit.gcid || ""))) { try { targetHit.hash = hashInfo.gcid; targetHit.gcid = hashInfo.gcid; } catch {} } if (hashInfo.md5 && !targetHit.md5_checksum) { try { targetHit.md5_checksum = hashInfo.md5; } catch {} } if (hashInfo.size && !targetHit.size) { try { targetHit.size = hashInfo.size; } catch {} } if (hashInfo.downloadUrl && !targetHit.web_content_link) { try { targetHit.web_content_link = hashInfo.downloadUrl; if (!targetHit.links) targetHit.links = {}; targetHit.links["application/octet-stream"] = { url: hashInfo.downloadUrl }; } catch {} } savedHit = _polishHitBeforeReturn(targetHit); const hasHashNow = /^[0-9A-Fa-f]{40}$/.test(String(savedHit.hash || savedHit.gcid || "")); const hasDlNow = !!(savedHit.web_content_link || (savedHit.links && Object.keys(savedHit.links).length > 0)); if (hasHashNow || hasDlNow) { console.log(`${consoleTag} ✅ 路径2命中（file_info补全）hash=${hasHashNow ? "✅" : "❌"} downloadUrl=${hasDlNow ? "✅" : "❌"}`); return savedHit; } console.warn(`${consoleTag} ⚠️ 路径2 file_info 返回但仍无有效 hash/downloadUrl，继续路径4/5`); } } catch (err2) { console.warn(`${consoleTag} ⚠️ 路径2(_fetchFileHash)异常: ${String(err2?.message || err2).slice(0, 200)}`); } } } // 🔑 2026-08 性能优化：分享页场景下路径1-3都未命中hash时，直接返回 // 路径4(drive/v1/files) 和路径5(share/save) 在分享页场景下均无效（返回404/401） // 跳过可节省 6-15 秒/文件的无谓等待 const _effectiveHit = savedHit && (/^[0-9A-Fa-f]{40}$/.test(String(savedHit.hash || savedHit.gcid || "")) || !!(savedHit.web_content_link || (savedHit.links && Object.keys(savedHit.links).length > 0))); if (shareId && passCodeToken && !_effectiveHit) { console.warn(`${consoleTag} ⚠️ 分享页短路：路径1-3未命中有效hash/downloadUrl，跳过路径4/5（已知404/401），直接返回 savedHit 由上层 sample 兜底`); if (savedHit) return _polishHitBeforeReturn(savedHit); return null; } // ------- 尝试 4：drive/v1/files/{id}?space=&usage=CONSUME // 🔑 修复：分享页上下文下尝试多种鉴权策略（原来只用匿名头，大概率失败） // 策略 A：Bearer token + share_id/pass_code_token query（用户已登录+有分享权限） // 策略 B：匿名头 + share_id/pass_code_token query（原来行为） // 策略 C：纯 Bearer token（无 share query，当自己文件访问） const path4Strategies = []; if (shareId && passCodeToken) { path4Strategies.push( { label: "Bearer+share_query", url: `${XUNLEI_API_BASE}/drive/v1/files/${encodeURIComponent(fileIdStr)}?space=&usage=CONSUME&share_id=${encodeURIComponent(shareId)}&pass_code_token=${encodeURIComponent(passCodeToken)}`, headers: authHeaders }, { label: "匿名+share_query", url: `${XUNLEI_API_BASE}/drive/v1/files/${encodeURIComponent(fileIdStr)}?space=&usage=CONSUME&share_id=${encodeURIComponent(shareId)}&pass_code_token=${encodeURIComponent(passCodeToken)}`, headers: _makeAnonymousHeaders() }, { label: "Bearer纯登录", url: `${XUNLEI_API_BASE}/drive/v1/files/${encodeURIComponent(fileIdStr)}?space=&usage=CONSUME`, headers: authHeaders }, ); } else { path4Strategies.push( { label: "登录头", url: `${XUNLEI_API_BASE}/drive/v1/files/${encodeURIComponent(fileIdStr)}?space=&usage=CONSUME`, headers: authHeaders }, ); } for (let si = 0; si < path4Strategies.length; si++) { const strat = path4Strategies[si]; try { // deviceId 一致性检查 const sDid = (strat.headers && (strat.headers["x-device-id"] || strat.headers["X-Device-Id"])) || ""; const helperDid = (typeof helper === "object" && helper._ensureStableDeviceId) ? helper._ensureStableDeviceId() : ""; if (sDid && helperDid && sDid !== helperDid) { strat.headers = { ...(strat.headers || {}) }; strat.headers["x-device-id"] = sDid; strat.headers["X-Device-Id"] = sDid; strat.headers["x-guid"] = sDid; strat.headers["X-Guid"] = sDid; } const sBearer = (strat.headers && strat.headers["Authorization"]) ? "有" : "❌无"; console.log(`${consoleTag} 🧭 路径4策略${si+1}/${path4Strategies.length} [${strat.label}] Bearer=${sBearer}`); const t = await helper.get(strat.url, strat.headers); const j = JSON.parse(t || "null"); if (j && (j.kind || j.id)) { const hasHash = /^[0-9A-Fa-f]{40}$/.test(String(j.hash || j.gcid || "")); const hasDl = !!(j.web_content_link || (j.links && Object.keys(j.links).length > 0)); console.log(`${consoleTag} ✅ 路径4命中 [${strat.label}] hash=${hasHash ? "✅" : "❌"} downloadUrl=${hasDl ? "✅" : "❌"} links=${JSON.stringify(j.links ? Object.keys(j.links) : [])}`); if (hasHash || hasDl) { return _polishHitBeforeReturn(j); } // 有结构但无 hash/downloadUrl → 保存为 savedHit 兜底 if (!savedHit) savedHit = _polishHitBeforeReturn(j); console.warn(`${consoleTag} ⚠️ 路径4 [${strat.label}] 有结构但无 hash/downloadUrl，继续下一策略`); } else { console.warn(`${consoleTag} ❌ 路径4 [${strat.label}] 返回空 resp=${String(t || "null").slice(0,200)}`); } } catch (e) { console.warn(`${consoleTag} ❌ 路径4 [${strat.label}] 异常:`, String(e && e.message ? e.message : e).slice(0, 240)); } } // ------- 路径 5：share/save 转存后获取详情（终极兜底） // 🔑 分享页文件不返回 hash/downloadUrl，先转存到用户网盘，再用 drive/v1/files/{id} 获取 // 注意：此路径会在用户网盘根目录创建文件，用于提取 gcid 后可手动删除 if (shareId && passCodeToken) { try { console.log(`${consoleTag} 🔄 路径5：尝试 share/save 转存后获取详情...`); const saveUrl = `${XUNLEI_API_BASE}/drive/v1/share/save`; const saveBody = { share_id: shareId, file_ids: [fileIdStr], pass_code_token: passCodeToken }; const saveRespInfo = await new Promise((resolve) => { GM_xmlhttpRequest({ method: "POST", url: saveUrl, headers: { ...authHeaders, "Content-Type": "application/json" }, data: JSON.stringify(saveBody), timeout: 15000, onload: (r) => resolve({ status: r.status, text: r.responseText || "" }), onerror: () => resolve({ status: 0, text: "" }), ontimeout: () => resolve({ status: 0, text: "" }), }); }); console.log(`${consoleTag} 📦 路径5 share/save 响应: HTTP ${saveRespInfo.status} body=${saveRespInfo.text.slice(0, 200)}`); if (saveRespInfo.status >= 200 && saveRespInfo.status < 300 && saveRespInfo.text) { const saveJson = JSON.parse(saveRespInfo.text); // 可能直接返回 task 对象 const taskId = saveJson.task_id || saveJson.id || ""; if (taskId) { // 轮询 task 直到完成 let newFileId = ""; for (let poll = 0; poll < 15; poll++) { await new Promise(r => setTimeout(r, 1000)); const taskUrl = `${XUNLEI_API_BASE}/drive/v1/tasks/${encodeURIComponent(taskId)}`; const taskRespInfo = await new Promise((resolve) => { GM_xmlhttpRequest({ method: "GET", url: taskUrl, headers: authHeaders, timeout: 10000, onload: (r) => resolve({ status: r.status, text: r.responseText || "" }), onerror: () => resolve({ status: 0, text: "" }), ontimeout: () => resolve({ status: 0, text: "" }), }); }); if (taskRespInfo.status >= 200 && taskRespInfo.status < 300 && taskRespInfo.text) { const taskJson = JSON.parse(taskRespInfo.text); console.log(`${consoleTag} 📦 路径5 task轮询[${poll+1}] phase=${taskJson.phase} progress=${taskJson.progress || 0}`); if (taskJson.phase === "PHASE_TYPE_COMPLETE") { // 提取新文件 ID（多种可能的字段名） newFileId = taskJson.file_ids?.[0] || taskJson.params?.file_id || taskJson.file_id || ""; if (!newFileId && taskJson.spaces) { // 尝试从 spaces 中提取 for (const sp of (Array.isArray(taskJson.spaces) ? taskJson.spaces : [])) { if (sp.file_ids?.[0]) { newFileId = sp.file_ids[0]; break; } } } if (!newFileId) { // 尝试从 response 中递归查找 file_id const _findFileId = (obj, depth) => { if (!obj || typeof obj !== "object" || depth > 5) return ""; if (obj.file_id && typeof obj.file_id === "string") return obj.file_id; if (Array.isArray(obj.file_ids) && obj.file_ids[0]) return String(obj.file_ids[0]); for (const k of Object.keys(obj)) { const v = obj[k]; if (typeof v === "object") { const found = _findFileId(v, depth + 1); if (found) return found; } } return ""; }; newFileId = _findFileId(taskJson, 0); } break; } if (taskJson.phase === "PHASE_TYPE_ERROR") { console.warn(`${consoleTag} ❌ 路径5：转存任务失败 phase=ERROR`); break; } } } if (newFileId) { console.log(`${consoleTag} 📦 路径5：转存完成，新文件ID=${newFileId.slice(0,20)}…，获取详情...`); const detailUrl = `${XUNLEI_API_BASE}/drive/v1/files/${encodeURIComponent(newFileId)}?space=&usage=CONSUME`; const detailText = await helper.get(detailUrl, authHeaders); const detailJson = JSON.parse(detailText || "null"); if (detailJson && (detailJson.kind || detailJson.id)) { const hasHash5 = /^[0-9A-Fa-f]{40}$/.test(String(detailJson.hash || detailJson.gcid || "")); const hasDl5 = !!(detailJson.web_content_link || (detailJson.links && Object.keys(detailJson.links).length > 0)); console.log(`${consoleTag} ✅ 路径5命中（share/save 转存）hash=${hasHash5 ? "✅" : "❌"} downloadUrl=${hasDl5 ? "✅" : "❌"}`); return _polishHitBeforeReturn(detailJson); } console.warn(`${consoleTag} ❌ 路径5：新文件详情为空 resp=${String(detailText || "null").slice(0,200)}`); } else { console.warn(`${consoleTag} ❌ 路径5：转存完成但未提取到新文件ID`); } } else { // 响应可能直接包含文件信息（非 task 模式） const directHash = /^[0-9A-Fa-f]{40}$/.test(String(saveJson.hash || saveJson.gcid || "")); const directDl = !!(saveJson.web_content_link || (saveJson.links && Object.keys(saveJson.links).length > 0)); if (directHash || directDl) { console.log(`${consoleTag} ✅ 路径5直接命中（share/save 响应含文件信息）`); return _polishHitBeforeReturn(saveJson); } console.warn(`${consoleTag} ❌ 路径5：share/save 响应无 task_id 也无文件信息`); } } else { console.warn(`${consoleTag} ❌ 路径5：share/save 失败 HTTP ${saveRespInfo.status}`); } } catch (err5) { console.warn(`${consoleTag} ❌ 路径5异常:`, String(err5?.message || err5).slice(0, 240)); } } // ------- 最终兜底：返回 savedHit（即使无 hash/downloadUrl） // 🔑 2026-08 性能优化：分享页场景下路径4/5已被短路，此处仅处理非分享页场景 if (savedHit) { console.log(`${consoleTag} ⚠️ 所有路径未命中 hash/downloadUrl，返回 savedHit 由 enrich 尝试 sample 计算`); return _polishHitBeforeReturn(savedHit); } return null; }, /** * 极速补全 entry 缺失字段（方案 A：跳过 HTTP 请求） * * 【原理】光鸭服务端秒传索引按「gcid + md5 + fileSize」匹配（迅雷原生协议最小集合）， * 即使没有 cid 和 downloadUrl，只要 gcid 是 40 位 hex，代码内部会用 * gcid.slice(0, 32) 作为 md5 兜底（迅雷客户端协议也这么干，导入端 L2253/L5049）， * 成功率已通过抓包验证。 * * 极速模式行为： * · 不调用 getFileDetail API（0 HTTP 请求） * · 不下载 3×20KB Range 样本计算 cid（0 次大文件 CDN 请求） * · 只用 list 接口已返回的 gcid / size / md5_checksum * · 若 md5 为空但 gcid 有 40 位 → 取 gcid 前 32 位作为 md5 兜底 * · gcid / size 缺失的条目才单独从持久化 GM 缓存中补（导入端算过 cid 的文件会留下） * * 性能收益：原 20 个大文件需 80+ HTTP 请求 + SHA-1 计算 → 现在瞬间完成 */ async enrichEntriesMissingHashes(entries, onProgress, shareCtx = null, opts = {}) { const total = entries.length; if (total === 0) return entries; const { allowDetailFetch = false, allowSampleCompute = false } = opts || {}; // 🔑 2026-08 性能优化：并发处理 const CONCURRENCY = 5; // 5 路并发 let patched = 0; let cacheHit = 0; let detailFetchCount = 0; let sampleComputeCount = 0; let completedCount = 0; // 先同步处理不需要 API 的步骤（GM缓存、size修复、md5兜底） // 并将需要 API 补全的文件分出来并发处理 const needApiList = []; for (let i = 0; i < entries.length; i++) { const e = entries[i]; if (!e) continue; // 1) gcid：优先已有值；若空尝试从 GM 持久化缓存按 fileId 补 if (!e.gcid) { if (e.fileId && typeof this.getCidFromFileId === "function") { try { const c = this.getCidFromFileId(e.fileId); if (c) { if (!e.gcid && c.gcid) { e.gcid = c.gcid; cacheHit++; } if (!e.md5 && c.md5) { e.md5 = c.md5; cacheHit++; } } } catch {} } } // 2) size：确保是数字 if (e.size === undefined || e.size === null || e.size === "") { if (typeof e.fileSize === "number") e.size = e.fileSize; else if (typeof e.length === "number") e.size = e.length; } const sz = Number(e.size) || 0; if (sz > 0) e.size = sz; // 3) md5 兜底 if (!e.md5 && e.gcid && /^[0-9A-Fa-f]{40}$/.test(String(e.gcid))) { e.md5 = String(e.gcid).toLowerCase().slice(0, 32); patched++; } // 判断是否需要 API 补全 const hasGcid = /^[0-9A-Fa-f]{40}$/.test(String(e.gcid || "")); const hasSize = Number(e.size) > 0; if (allowDetailFetch && e.fileId && (!hasGcid || !hasSize)) { needApiList.push({ index: i, entry: e }); } else { // 不需要 API 的，直接标记完成 completedCount++; if (typeof onProgress === "function") { try { onProgress(completedCount, total, e); } catch {} } } } // 🔑 并发处理需要 API 补全的文件（5路并发） if (needApiList.length > 0) { console.log(`[迅雷提取] 🚀 开始并发补全 ${needApiList.length} 个文件（${CONCURRENCY}路并发）...`); const _self = this; const _shareId = shareCtx?.shareId || ""; const _pct = shareCtx?.passCodeToken || ""; async function processOne(item) { const { index, entry: e } = item; let detail = null; try { const rawDetail = await _self.getFileDetail( e.fileId, _shareId, _pct, { parentId: e.parentId || "" } ); detail = rawDetail; if (detail && typeof detail === "object") { const norm = _self._normalizeFileEntry( detail, e.path || detail.name || "", e.parentId || detail.parent_id || "" ); if (!norm.downloadUrl && rawDetail && typeof _self._extractDlFromDetailFlat === "function") { const flatDl = _self._extractDlFromDetailFlat(rawDetail); if (flatDl) { norm.downloadUrl = flatDl; } } detail = norm; const hasGcid = /^[0-9A-Fa-f]{40}$/.test(String(e.gcid || "")); const hasSize = Number(e.size) > 0; if (!hasGcid && norm.gcid) { e.gcid = norm.gcid; detailFetchCount++; } if (!hasSize && norm.size) { e.size = norm.size; } if (!e.md5 && norm.md5) { e.md5 = norm.md5; } if (!e.downloadUrl && norm.downloadUrl) { e.downloadUrl = norm.downloadUrl; } } } catch (err) { // 静默失败 } // 4b) 🔑 性能优化：getFileDetail 内部快速通道已调过 _fetchFileHash， // 只有 gcid 仍为空时才重试（正常情况下快速通道已命中，这里直接跳过） const stillNoGcid = !/^[0-9A-Fa-f]{40}$/.test(String(e.gcid || "")); const stillNoSize = Number(e.size) <= 0; if (_shareId && _pct && (stillNoGcid || stillNoSize) && typeof _self._fetchFileHash === "function") { try { const hi = await _self._fetchFileHash(e.fileId, _shareId, _pct); if (hi) { if (hi.gcid && stillNoGcid) { e.gcid = hi.gcid; detailFetchCount++; } if (hi.md5 && !e.md5) e.md5 = hi.md5; if (hi.size && stillNoSize) e.size = hi.size; if (hi.downloadUrl && !e.downloadUrl) { e.downloadUrl = hi.downloadUrl; if (detail) detail.downloadUrl = hi.downloadUrl; } } } catch {} } // 5) sample 计算 if (allowSampleCompute && e.fileId && !/^[0-9A-Fa-f]{40}$/.test(String(e.gcid || ""))) { const dlUrl = e.downloadUrl || (detail && detail.downloadUrl) || ""; const size = Number(e.size) || Number(detail && detail.size) || 0; if (dlUrl && size > 0) { try { const computed = await _self.computeCidFromDownloadUrl(dlUrl, size); if (computed.gcid) { e.gcid = computed.gcid; e.tripleCid = computed.tripleCid; e.wholeCid = computed.wholeCid; e.cid = computed.gcid; if (!e.downloadUrl) e.downloadUrl = computed.downloadUrl; sampleComputeCount++; } } catch {} } } // 6) 再次 md5 兜底 if (!e.md5 && e.gcid && /^[0-9A-Fa-f]{40}$/.test(String(e.gcid))) { e.md5 = String(e.gcid).toLowerCase().slice(0, 32); patched++; } completedCount++; if (typeof onProgress === "function") { try { onProgress(completedCount, total, e); } catch {} } } // 并发执行（控制并发数） const results = []; let cursor = 0; async function worker() { while (cursor < needApiList.length) { const idx = cursor++; await processOne(needApiList[idx]); results.push(idx); } } const workers = []; for (let w = 0; w < Math.min(CONCURRENCY, needApiList.length); w++) { workers.push(worker()); } await Promise.all(workers); } else { // 全部在极速模式下完成 if (typeof onProgress === "function") { try { onProgress(total, total, entries[entries.length - 1]); } catch {} } } // 结束日志：极速模式完成情况一眼可见 const summary = { total, gcidOK: entries.filter(x => x && /^[0-9A-Fa-f]{40}$/.test(String(x.gcid || ""))).length, md5OK: entries.filter(x => x && /^[0-9A-Fa-f]{32}$/.test(String(x.md5 || ""))).length, sizeOK: entries.filter(x => x && Number(x.size) > 0).length, patched, cacheHit, detailFetchCount, sampleComputeCount, }; console.log( "[迅雷提取 enrichEntriesMissingHashes] ✅ 极速模式完成：" + "total=" + summary.total + " gcid=" + summary.gcidOK + "/" + summary.total + " md5=" + summary.md5OK + "/" + summary.total + " size=" + summary.sizeOK + "/" + summary.total + " (gcid兜底md5=" + summary.patched + "条，GM缓存命中=" + summary.cacheHit + "条，detail补全=" + summary.detailFetchCount + "条，sample计算=" + summary.sampleComputeCount + "条) —— " + (allowDetailFetch ? "最多" + total + "次detail请求" : "0次HTTP请求") + (allowSampleCompute ? "，sample计算已开启" : "") ); return entries; }, /** * 🔑 持久化凭证读取：用户可能先在 pan.xunlei.com 提取 JSON（拦截器捕获 captcha_token 并持久化到 GM_setValue）， * 然后切到 guangyapan.com 导入 JSON（此时 _cachedCaptchaToken 为空，需要从 GM_getValue 读取）。 * captcha_token 是迅雷的【无感验证码令牌】（AES加密行为数据+Protobuf元数据），无法在脚本端生成， * 只能从迅雷页面的真实请求中拦截。有效期约 1-24 小时，这里用 2 小时做安全过期。 */ _getPersistentCaptchaToken() { // 1) 优先用运行时缓存（当前页面拦截到的） if (this._cachedCaptchaToken) return this._cachedCaptchaToken; // 2) 从 GM_getValue 读取（其他页面拦截并持久化的） try { const raw = GM_getValue("xunlei_captcha_token", ""); if (raw) { const parsed = JSON.parse(raw); if (parsed && parsed.token && parsed.ts) { const ageMs = Date.now() - parsed.ts; // 2 小时有效期（迅雷 captcha_token 实测 1-24h，取保守值） if (ageMs < 2 * 60 * 60 * 1000) { console.log(`[迅雷凭证] 📖 从 GM_getValue 读取持久化 captcha_token（${Math.round(ageMs / 1000 / 60)}分钟前捕获，长度=${parsed.token.length}）`); this._cachedCaptchaToken = parsed.token; return parsed.token; } else { console.warn(`[迅雷凭证] ⚠️ 持久化 captcha_token 已过期（${Math.round(ageMs / 1000 / 60)}分钟前捕获）→ 尝试自动刷新`); // 🔑 2026-08 新增：token 过期时尝试自动刷新 const refreshed = this._refreshCaptchaToken(); if (refreshed) return refreshed; } } } else { // GM 没有值，也尝试刷新一次 const refreshed = this._refreshCaptchaToken(); if (refreshed) return refreshed; } } catch {} return ""; }, /** * 🔑 2026-08 新增：自动刷新 captcha_token * 策略： * 1) 先从 localStorage / sessionStorage 里扫一遍有没有现成的 * 2) 如果在迅雷页面上下文，尝试调 captcha/init 接口拿新的 * 3) 如果页面有未完成的 Fetch/XHR，尝试监听下一个请求拦截 token * @returns {string} 新 token 或空串 */ _refreshCaptchaToken() { const consoleTag = "[迅雷凭证 _refreshCaptchaToken]"; try { // 1) 扫 localStorage / sessionStorage const storageKeys = ["captcha", "captchaToken", "captcha_token", "x_captcha_token", "xCaptchaToken"]; for (const key of storageKeys) { try { let v = localStorage.getItem(key) || sessionStorage.getItem(key) || ""; if (v) { // 可能是 JSON，也可能是直接字符串 let tokenStr = ""; try { const p = JSON.parse(v); tokenStr = String(p?.token || p?.captcha_token || p?.value || v || "").trim(); } catch { tokenStr = v.trim(); } if (tokenStr.length > 100 && /^[A-Za-z0-9_\-=+\/.]+$/.test(tokenStr)) { console.log(`${consoleTag} ✅ 从 localStorage[${key}] 挖出 captcha_token（长度=${tokenStr.length}）`); this._cachedCaptchaToken = tokenStr; try { GM_setValue("xunlei_captcha_token", JSON.stringify({ token: tokenStr, ts: Date.now() })); } catch {} return tokenStr; } } } catch {} } // 扫整个 localStorage 找像 captcha 的长 token try { for (let i = 0; i < localStorage.length; i++) { const k = localStorage.key(i) || ""; if (/captcha|ctoken|sign|verify/i.test(k)) { const v = localStorage.getItem(k) || ""; if (v.length > 100 && v.length < 5000 && /^[A-Za-z0-9_\-=+\/.%]+$/.test(v)) { console.log(`${consoleTag} ✅ 从 localStorage 模糊匹配 [${k}] 挖出 captcha_token（长度=${v.length}）`); this._cachedCaptchaToken = v; try { GM_setValue("xunlei_captcha_token", JSON.stringify({ token: v, ts: Date.now() })); } catch {} return v; } } } } catch {} // 2) 调 captcha/init 接口（只在迅雷页面域名下尝试，避免跨域） if (location.hostname === "pan.xunlei.com" || location.hostname.endsWith(".xunlei.com")) { try { const did = this._getPersistentDeviceId(); // 构造一个轻量的 captcha init 请求（迅雷 Web 端真实格式） const initCandidates = [ { method: "GET", url: `https://api-pan.xunlei.com/drive/v1/captcha/init?client_id=${encodeURIComponent(this._cachedClientId || XUNLEI_CLIENT_ID)}&device_id=${encodeURIComponent(did)}&action=share`, }, { method: "POST", url: `https://api-pan.xunlei.com/drive/v1/captcha/init`, body: { client_id: this._cachedClientId || XUNLEI_CLIENT_ID, device_id: did, action: "share_detail" }, }, { method: "GET", url: `https://captcha.xunlei.com/init?client_id=${encodeURIComponent(this._cachedClientId || XUNLEI_CLIENT_ID)}&device_id=${encodeURIComponent(did)}`, }, ]; // 注意：这个请求只是触发脚本拦截器捕获 token，因为响应里通常不会直接给 token // 所以这里不 await，只是异步发一下 for (let ci = 0; ci < initCandidates.length; ci++) { try { const cand = initCandidates[ci]; const headers = { "x-client-id": this._cachedClientId || XUNLEI_CLIENT_ID, "Referer": "https://pan.xunlei.com/", }; if (did) { headers["x-device-id"] = did; headers["X-Device-Id"] = did; } const token = this._getPersistentBearerToken(); if (token) headers["Authorization"] = `Bearer ${token}`; if (cand.method === "GET") { fetch(cand.url, { headers, credentials: "include" }).catch(() => {}); } else { fetch(cand.url, { method: "POST", headers: { ...headers, "Content-Type": "application/json" }, body: JSON.stringify(cand.body || {}), credentials: "include" }).catch(() => {}); } } catch {} } console.log(`${consoleTag} 💡 已发起 captcha/init 请求（异步），请稍后查看拦截器日志。若仍无 token，请手动刷新页面或点击任意文件夹触发一次列表请求。`); } catch (e) { console.warn(`${consoleTag} ⚠️ captcha/init 请求失败: ${String(e?.message || e).slice(0, 120)}`); } } } catch (e) { console.warn(`${consoleTag} ⚠️ 整体异常: ${String(e?.message || e).slice(0, 200)}`); } return ""; }, _getPersistentBearerToken() { if (this._cachedToken) return this._cachedToken; try { const raw = GM_getValue("xunlei_bearer_token", ""); if (raw) { const parsed = JSON.parse(raw); if (parsed && parsed.token && parsed.ts) { const ageMs = Date.now() - parsed.ts; if (ageMs < 24 * 60 * 60 * 1000) { // Bearer token 24h 有效 this._cachedToken = parsed.token; return parsed.token; } } } } catch {} return ""; }, _getPersistentDeviceId() { if (this._cachedDeviceId) return this._cachedDeviceId; try { const did = GM_getValue("xunlei_device_id_intercepted", ""); if (did) { this._cachedDeviceId = did; return did; } } catch {} // 最终兜底：helper 的稳定 deviceId if (typeof helper === "object" && helper && typeof helper._ensureStableDeviceId === "function") { try { return helper._ensureStableDeviceId() || ""; } catch {} } return ""; }, /** * 🔑 从【持久化缓存】读取迅雷 fileId → cid 映射（panGuangya 有同名方法，这里是迅雷版） * enrichEntriesMissingHashes 在提取端算好 cid 后会写入 GM_setValue。 * 导入端即使 JSON 里的 cid 字段丢了/没写对，只要 fileId 相同，就能跨标签页、跨域名直接从缓存拿。 * 有效期：24 小时（cid 是永久值，但缓存设过期避免无限增长） */ getCidFromFileId(fileId) { const id = String(fileId || "").trim(); if (!id) return {}; try { const raw = GM_getValue("xunlei_fileid_cid_cache_v1", ""); if (!raw) return {}; const cache = JSON.parse(raw) || {}; const c = cache[id]; if (!c || typeof c !== "object") return {}; // 24h 有效期 if (c.ts && Date.now() - Number(c.ts || 0) > 24 * 60 * 60 * 1000) return {}; const triple = /^[0-9A-Fa-f]{40}$/.test(String(c.tripleCid || "")) ? String(c.tripleCid).toLowerCase() : ""; const whole = /^[0-9A-Fa-f]{40}$/.test(String(c.wholeCid || "")) ? String(c.wholeCid).toLowerCase() : ""; const md5 = /^[0-9A-Fa-f]{32}$/.test(String(c.md5 || "")) ? String(c.md5).toLowerCase() : ""; if (!triple && !whole) return {}; console.log(`[迅雷秒传 GM cache] ✅ fileId=${id.slice(0,20)}… 命中持久化缓存（triple=${triple ? "有" : "无"} whole=${whole ? "有" : "无"}）`); return { tripleCid: triple, wholeCid: whole, gcid: String(c.gcid || ""), md5: md5, downloadUrl: String(c.downloadUrl || ""), size: String(c.size || ""), }; } catch {} return {}; }, /** * 🔑 鉴权头切换：【有登录模式】vs【匿名模式】 * · 登录模式（默认）：有 token 就写 Authorization: Bearer ；没有就不写（避免写 Bearer 空串触发 401 invalid_token） * · 匿名模式（分享页专用）：完全省略 Authorization 头，只带 deviceId + clientId + captchaToken； * 迅雷分享页接口（share/detail / share/*download*）匿名用户本来就能访问，传了用户自己的 Bearer token * 反而会因为「分享不属于当前用户」被后端打回，永远拿不到 downloadUrl。 */ useAnonymousAuth(flag = true) { try { this._useAnonymousAuth = !!flag; } catch {} }, /** * 🔑 分享页专用匿名头：不带 Authorization Bearer，避免访问他人分享时 401/403 * 保留 captcha_token / device_id / x-client-id（这些是反验证码/设备标识，不是用户鉴权） * 原理：迅雷分享接口靠 pass_code_token 鉴权，传自己的 Bearer 反而会被校验"分享 owner==当前用户" * 返回 not_match → 401/403，永远拿不到 downloadUrl */ _getShareAnonymousHeaders() { const prev = this._useAnonymousAuth; try { this._useAnonymousAuth = true; return this.getAuthHeaders(); } finally { this._useAnonymousAuth = prev; } }, /** * 🔑 2026-08 迅雷改版新增：分享页专用 file_info 接口获取 hash(gcid) * 新版迅雷把 share/detail 接口的 hash 字段隐藏了（返回 null）， * 但保留了 /drive/v1/share/file_info 接口单独返回 hash(gcid)。 * 此方法专门调这个接口，仅用于补全缺失的 gcid。 * * @param {string} fileId 文件 ID * @param {string} shareId 分享 ID * @param {string} passCodeToken 提取码 token * @returns {Promise<{gcid:string, md5:string, size:number, downloadUrl:string}>} */ async _fetchFileHash(fileId, shareId, passCodeToken) { const consoleTag = "[迅雷提取 _fetchFileHash]"; if (!fileId || !shareId || !passCodeToken) { console.warn(`${consoleTag} ⚠️ 参数不全，跳过 file_info 请求`); return null; } const anon = this._getShareAnonymousHeaders(); const hasCaptcha = !!(anon["x-captcha-token"] || anon["x-captcha"]); if (!hasCaptcha) { console.warn(`${consoleTag} ⚠️ captcha_token 不可用，file_info 接口会返回 400`); return null; } // 尝试多个可能的 file_info 路径（按命中率排序，只试最有效的2个） // 🔑 2026-08 性能优化：从5个候选减到2个，节省 60% 请求时间 const candidates = [ // 路径 A：标准 file_info 接口（GET + file_id 参数）— 已验证可返回 file_info { method: "GET", url: `${XUNLEI_API_BASE}/drive/v1/share/file_info?share_id=${encodeURIComponent(shareId)}&file_id=${encodeURIComponent(fileId)}&pass_code_token=${encodeURIComponent(passCodeToken)}&usage=CONSUME`, }, // 路径 B：带 space 参数的变体 { method: "GET", url: `${XUNLEI_API_BASE}/drive/v1/share/file_info?share_id=${encodeURIComponent(shareId)}&file_id=${encodeURIComponent(fileId)}&pass_code_token=${encodeURIComponent(passCodeToken)}&space=&usage=CONSUME`, }, ]; for (let i = 0; i < candidates.length; i++) { const cand = candidates[i]; try { let respText = ""; let respStatus = 0; if (cand.method === "GET") { // 🔑 性能优化：file_info 是轻量查询，用 GM_xmlhttpRequest 直接发（5秒超时） const respInfo = await new Promise((resolve) => { GM_xmlhttpRequest({ method: "GET", url: cand.url, headers: anon, timeout: 5000, // 5 秒超时（比 helper.get 默认 15 秒快 3 倍） onload: (r) => resolve({ status: r.status, text: r.responseText || "" }), onerror: () => resolve({ status: 0, text: "" }), ontimeout: () => resolve({ status: 0, text: "" }), }); }); respStatus = respInfo.status; respText = respInfo.text; } if (respStatus >= 200 && respStatus < 300 && respText) { const j = JSON.parse(respText || "null"); if (!j) continue; // 从各种可能的字段中提取 hash/gcid/md5/size let gcid = ""; let md5 = ""; let size = 0; let downloadUrl = ""; const _tryExtract = (obj) => { if (!obj || typeof obj !== "object") return; const h = String(obj.hash || obj.gcid || obj.sha1 || obj.sha_1 || obj.sha1sum || "").trim(); if (/^[0-9A-Fa-f]{40}$/.test(h) && !gcid) gcid = h.toLowerCase(); const m = String(obj.md5 || obj.md5sum || obj.md5_checksum || "").trim(); if (/^[0-9A-Fa-f]{32}$/.test(m) && !md5) md5 = m.toLowerCase(); const s = Number(obj.size || obj.file_size || obj.length || 0); if (s > 0 && !size) size = s; const d = String(obj.web_content_link || obj.download_url || obj.url || "").trim(); if (d && !downloadUrl && !/\.png|\.jpg|\.jpeg|\.gif|\.webp/i.test(d)) downloadUrl = d; if (obj.links && typeof obj.links === "object") { for (const k of Object.keys(obj.links)) { const u = String(obj.links[k]?.url || obj.links[k] || "").trim(); if (u && !downloadUrl && !/\.png|\.jpg|\.jpeg|\.gif|\.webp/i.test(u)) downloadUrl = u; } } }; // 尝试多个层级 _tryExtract(j); _tryExtract(j.data); _tryExtract(j.file); _tryExtract(j.info); _tryExtract(j.file_info); // 🔑 修复：file_info 接口返回的层级 _tryExtract(j.fileInfo); if (Array.isArray(j.files)) j.files.forEach(_tryExtract); if (gcid || md5 || downloadUrl) { console.log(`${consoleTag} ✅ 路径${String.fromCharCode(65 + i)}命中 gcid=${gcid ? "✅" : "❌"} md5=${md5 ? "✅" : "❌"} size=${size || "❌"} downloadUrl=${downloadUrl ? "✅" : "❌"}`); return { gcid, md5, size, downloadUrl }; } // 🔑 调试日志：打印 file_info 的所有字段名，便于定位 hash 字段 const _fileInfoObj = j.file_info || j.fileInfo || j.file || j.data || j; const _allKeys = (_fileInfoObj && typeof _fileInfoObj === "object") ? Object.keys(_fileInfoObj).join(",") : "(非对象)"; console.warn(`${consoleTag} ⚠️ 路径${String.fromCharCode(65 + i)}: 2xx 但无 hash 字段。file_info 字段列表: ${_allKeys} resp=${respText.slice(0, 500)}`); } else if (respStatus > 0) { console.warn(`${consoleTag} ⚠️ 路径${String.fromCharCode(65 + i)}: HTTP ${respStatus} resp=${respText.slice(0, 200)}`); } } catch (e) { console.warn(`${consoleTag} ⚠️ 路径${String.fromCharCode(65 + i)}异常: ${String(e?.message || e).slice(0, 200)}`); } } console.warn(`${consoleTag} ❌ 所有路径均未返回 hash(gcid)`); return null; }, getAuthHeaders() { // 🛡️【根因修复】迅雷 API 从 2026-07 底开始强制校验 device_id 非空： // 缺 X-Device-Id 头会直接返回 HTTP 400 invalid_argument（detail: device_id is empty） // 即使 URL query 里有 device_id=，也最好同步写 header 双保险（有些后端分支只看 header） const token = this._getPersistentBearerToken(); const captchaToken = this._getPersistentCaptchaToken(); const clientId = this._cachedClientId || XUNLEI_CLIENT_ID; // 1) 拦截器抓到的真实 x-device-id 优先（和迅雷 Web 端一致，风控最稳） let deviceId = this._getPersistentDeviceId(); const h = { "Content-Type": "application/json", "x-client-id": clientId, "Referer": "https://pan.xunlei.com/", }; if (deviceId) { // 大小写双写：迅雷 Access-Control-Allow-Headers 里显式列了 X-Device-Id,X-Guid h["x-device-id"] = deviceId; h["X-Device-Id"] = deviceId; h["x-guid"] = deviceId; h["X-Guid"] = deviceId; } // 🛡️ captcha_token 是反验证码令牌（不是用户鉴权），所有接口都要求，必须带上 if (captchaToken) { h["x-captcha-token"] = captchaToken; } // 🛡️【关键】匿名模式（分享页）→ 完全省略 Authorization 头，避免把自己的登录 token 传到别人的分享接口 const anonymousMode = !!this._useAnonymousAuth; if (!anonymousMode && token) h["Authorization"] = `Bearer ${token}`; return h; }, installTokenInterceptor() { if (this._interceptorInstalled) return; this._interceptorInstalled = true; const self = this; const origOpen = XMLHttpRequest.prototype.open; const origSetHeader = XMLHttpRequest.prototype.setRequestHeader; XMLHttpRequest.prototype.open = function (method, url) { this._url = url; this._headers = {}; return origOpen.apply(this, arguments); }; XMLHttpRequest.prototype.setRequestHeader = function (name, value) { if (this._headers) this._headers[String(name).toLowerCase()] = value; return origSetHeader.apply(this, arguments); }; const origSend = XMLHttpRequest.prototype.send; XMLHttpRequest.prototype.send = function () { if (this._url && String(this._url).includes("api-pan.xunlei.com") && this._headers) { const auth = this._headers["authorization"] || ""; if (auth.startsWith("Bearer ")) { self._cachedToken = auth.slice(7).trim(); try { GM_setValue("xunlei_bearer_token", JSON.stringify({ token: self._cachedToken, ts: Date.now() })); } catch {} } const did = this._headers["x-device-id"] || ""; if (did) { self._cachedDeviceId = did; try { GM_setValue("xunlei_device_id_intercepted", did); } catch {} try { helper._setStableDeviceId(did); } catch {} } const ct = this._headers["x-captcha-token"] || ""; if (ct) { self._cachedCaptchaToken = ct; try { GM_setValue("xunlei_captcha_token", JSON.stringify({ token: ct, ts: Date.now() })); } catch {} console.log("[迅雷拦截器] ✅ XHR 捕获 captcha_token 并持久化（长度=" + ct.length + "）"); } const cid = this._headers["x-client-id"] || ""; if (cid) self._cachedClientId = cid; } return origSend.apply(this, arguments); }; // 同时拦截 fetch const origFetch = unsafeWindow.fetch || window.fetch; const patchedFetch = function (input, init) { const url = typeof input === "string" ? input : input?.url || ""; if (url.includes("api-pan.xunlei.com") && init && init.headers) { const headers = init.headers; const getH = (k) => { if (typeof headers.get === "function") return headers.get(k) || ""; if (typeof headers === "object") { for (const key of Object.keys(headers)) { if (key.toLowerCase() === k.toLowerCase()) return headers[key]; } } return ""; }; const auth = getH("authorization"); if (auth.startsWith("Bearer ")) { self._cachedToken = auth.slice(7).trim(); try { GM_setValue("xunlei_bearer_token", JSON.stringify({ token: self._cachedToken, ts: Date.now() })); } catch {} } const did = getH("x-device-id"); if (did) { self._cachedDeviceId = did; try { GM_setValue("xunlei_device_id_intercepted", did); } catch {} try { helper._setStableDeviceId(did); } catch {} } const ct = getH("x-captcha-token"); if (ct) { self._cachedCaptchaToken = ct; try { GM_setValue("xunlei_captcha_token", JSON.stringify({ token: ct, ts: Date.now() })); } catch {} console.log("[迅雷拦截器] ✅ Fetch 捕获 captcha_token 并持久化（长度=" + ct.length + "）"); } const cid = getH("x-client-id"); if (cid) self._cachedClientId = cid; } return origFetch.apply(this, arguments); }; if (unsafeWindow && unsafeWindow.fetch) unsafeWindow.fetch = patchedFetch; else window.fetch = patchedFetch; // ⏱️ 【拦截器时序问题】油猴 @run-at 不一定早于页面首 XHR。 // 用户打开 pan.xunlei.com → 迅雷官方 JS 先跑了 N 个 API 请求（带 Bearer + captcha）→ 拦截器才装好。 // 结果：_cachedToken/_cachedCaptchaToken/_cachedDeviceId 全空，enrich 全挂。 // 🔧 兜底：拦截器装好后，立刻从 localStorage/sessionStorage/window 全局里再扫描一遍。 try { self._bootstrapTokensFromLocalPageContext(); } catch {} }, /** * 🔑 兜底：从 localStorage / sessionStorage / window 全局扫描 token（解决拦截器安装时序问题） * 用户点导出按钮时，页面已经加载很久了，迅雷官方 JS 肯定已经把 token 存进 storage 或全局变量里。 * 这一步能保证即使拦截器没抓到第一波 XHR，也能从页面上下文里挖出 token。 * 只在 pan.xunlei.com 域名下有效（跨域读不到别的站点的 localStorage）。 */ _bootstrapTokensFromLocalPageContext() { const self = this; // 🔑 重要修正：captcha_token 是迅雷实时生成的无感验证码签名（AES+Protobuf，500+字符）， // 不会被持久化到 storage —— 只能通过 XHR 拦截器在请求时刻捕获。 // bootstrap 只挖 Bearer token / deviceId / clientId 三种持久化 token。 // deviceId 单一数据源：Web 版（wd110.xxx）优先，其次是 helper 自生成的 32hex 稳定值。 let foundBearer = 0, foundDid = 0, foundClient = 0; let candidateWebDid = ""; // wd110.xxx 格式（迅雷 Web 原生，和 captcha_token 绑定） let candidateStableDid = ""; // helper 自生成的稳定值 const saveBearer = (t, src) => { if (!t || typeof t !== "string" || t.length < 10) return; if (t.startsWith("Bearer ")) t = t.slice(7).trim(); if (!t) return; // 🔑 关键：选最长的 Bearer token（credentials.access_token 798字符是完整登录态， // xpan_pass_token 88字符是分享页一次性 pass，不能混用） if (!self._cachedToken || t.length > self._cachedToken.length) { self._cachedToken = t; foundBearer++; } // GM 持久化：同样取最长的那个 let shouldPersist = true; try { const oldRaw = GM_getValue("xunlei_bearer_token", ""); if (oldRaw) { const old = JSON.parse(oldRaw); if (old && old.token && old.token.length >= t.length) shouldPersist = false; } } catch {} if (shouldPersist) { try { GM_setValue("xunlei_bearer_token", JSON.stringify({ token: t, ts: Date.now() })); } catch {} } console.log(`[迅雷bootstrap] ✅ ${src} 挖出 Bearer token（长度=${t.length}${shouldPersist ? "，已持久化" : "，短于现有未覆盖"}）`); }; // 🔑 deviceId 收集器：Web 版（wd110.xxx 格式，和 captcha_token 绑定）优先级高于 32hex 稳定值 const saveDeviceId = (t, src) => { if (!t || typeof t !== "string" || t.length < 6) return; const ts = String(t).trim(); if (/^wd[a-z0-9._-]{10,}/i.test(ts)) { if (!candidateWebDid) candidateWebDid = ts; } else { if (!candidateStableDid) candidateStableDid = ts; } }; const saveClient = (t, src) => { if (!t || typeof t !== "string" || t.length < 5) return; if (!self._cachedClientId) { self._cachedClientId = t; foundClient++; } }; // ① 扫描 localStorage / sessionStorage for (const storage of [typeof unsafeWindow !== "undefined" ? unsafeWindow.localStorage : null, typeof unsafeWindow !== "undefined" ? unsafeWindow.sessionStorage : null]) { if (!storage) continue; for (let i = 0; i < storage.length; i++) { let k = ""; try { k = storage.key(i); } catch {} if (!k) continue; const kLower = String(k).toLowerCase(); let v = ""; try { v = storage.getItem(k) || ""; } catch {} if (!v) continue; // Bearer token 识别（严格：key 必须含鉴权关键字，且值是 JWT/base64 样式，不含 device/guid/captcha） if (/bearer|access[_-]?token|auth[_-]?token|jwt|pass[_-]?token|user[_-]?token/i.test(kLower) && !/device|guid|did|captcha|risk|verify|client/i.test(kLower) && /^[A-Za-z0-9._\-=/+]{20,}$/.test(v)) { saveBearer(v, `storage[${k}]`); } if (/device|guid|client[_-]?id|did/i.test(kLower)) { if (/device|guid|did/i.test(kLower)) saveDeviceId(v, `storage[${k}]`); if (/client[_-]?id/i.test(kLower)) saveClient(v, `storage[${k}]`); } // value 内嵌 JSON：尝试 parse，递归找 bearer/device if (/^[{["\s]/.test(v)) { try { const j = JSON.parse(v); const walk = (obj) => { if (!obj || typeof obj !== "object") return; if (Array.isArray(obj)) { obj.forEach(walk); return; } for (const kk of Object.keys(obj)) { const vv = obj[kk]; const kkLower = String(kk).toLowerCase(); if (typeof vv === "string") { if (/bearer|access[_-]?token|auth[_-]?token|jwt|pass[_-]?token/i.test(kkLower) && vv.length >= 20 && !/device|guid|did|captcha/i.test(kkLower)) { saveBearer(vv, `storage[${k}].${kk}`); } if (/device|guid|did/i.test(kkLower)) saveDeviceId(vv, `storage[${k}].${kk}`); if (/client[_-]?id/i.test(kkLower)) saveClient(vv, `storage[${k}].${kk}`); } else if (typeof vv === "object") walk(vv); } }; walk(j); } catch {} } } } // ③ 扫描 window 全局：常见名字 window.__TOKEN__ / __ACCESS_TOKEN__ / userInfo / authInfo / $store.state const w = (typeof unsafeWindow !== "undefined" ? unsafeWindow : (typeof window !== "undefined" ? window : null)); if (w && typeof w === "object") { // 🔑 不再扫 captcha 相关 key —— captcha_token 是实时生成的，不会持久化在 window 里 const knownKeys = ["__TOKEN__", "__ACCESS_TOKEN__", "__AUTH__", "__CLIENT_ID__", "__DEVICE_ID__", "__GUID__", "accessToken", "access_token", "authToken", "clientId", "deviceId", "device_id", "guid"]; const visit = (obj, prefix) => { if (!obj || typeof obj !== "object" || prefix.length > 6) return; for (const kk of Object.keys(obj)) { const kkLower = String(kk).toLowerCase(); let vv; try { vv = obj[kk]; } catch { continue; } const vType = typeof vv; if (vType === "string") { // 🔑 Bearer 识别：排除 device/guid/did/captcha 相关 key if (/bearer|access[_-]?token|auth[_-]?token|jwt|pass[_-]?token/i.test(kkLower) && !/device|guid|did|captcha|risk|verify|client/i.test(kkLower) && vv.length >= 20) { saveBearer(vv, `${prefix}.${kk}`); } if (/device|guid|did/i.test(kkLower)) saveDeviceId(vv, `${prefix}.${kk}`); if (/client[_-]?id/i.test(kkLower)) saveClient(vv, `${prefix}.${kk}`); } else if (vType === "object" && vv !== null) { const nameHit = /user|auth|login|session|store|state|pinia|vuex|redux|app|config/i.test(kkLower); if (nameHit || knownKeys.some(k => k.toLowerCase() === kkLower)) visit(vv, prefix + "." + kk); } } }; try { visit(w, "window"); } catch {} try { if (w.__INITIAL_STATE__) visit(w.__INITIAL_STATE__, "window.__INITIAL_STATE__"); } catch {} try { if (w.$store && w.$store.state) visit(w.$store.state, "window.$store.state"); } catch {} try { if (w.app && w.app.config && w.app.config.globalProperties) visit(w.app.config.globalProperties, "window.app.config.globalProperties"); } catch {} } // ④ 扫 document.cookie：迅雷会把 device_id 写在 cookie 里 let cookies = ""; try { cookies = String(document.cookie || ""); } catch {} if (cookies) { const cookieScan = [ { re: /(?:^|;\s*)device_id\s*=\s*([^;\s]+)/i, fn: saveDeviceId, name: "cookie[device_id]" }, { re: /(?:^|;\s*)guid\s*=\s*([^;\s]+)/i, fn: saveDeviceId, name: "cookie[guid]" }, { re: /(?:^|;\s*)did\s*=\s*([^;\s]+)/i, fn: saveDeviceId, name: "cookie[did]" }, { re: /(?:^|;\s*)access_token\s*=\s*([^;\s]+)/i, fn: saveBearer, name: "cookie[access_token]" }, { re: /(?:^|;\s*)client[_-]?id\s*=\s*([^;\s]+)/i, fn: saveClient, name: "cookie[client_id]" }, ]; for (const cs of cookieScan) { const m = cookies.match(cs.re); if (m && m[1]) cs.fn(decodeURIComponent(m[1]), cs.name); } } // 🔑 最终确定单一 deviceId：Web 版（wd110.xxx）优先，否则用 helper 自生成的稳定值 // 选定后同步到 helper._setStableDeviceId()，保证后续所有 headers/query 都用同一个 deviceId const finalDid = candidateWebDid || candidateStableDid; if (finalDid) { self._cachedDeviceId = finalDid; foundDid++; try { helper._setStableDeviceId(finalDid); } catch {} try { GM_setValue("xunlei_device_id_intercepted", finalDid); } catch {} console.log(`[迅雷bootstrap] ✅ 最终 deviceId 选定：${finalDid.slice(0, 20)}… (${candidateWebDid ? "Web原生" : "稳定值"}) 已同步到 helper`); } const total = foundBearer + foundDid + foundClient; if (total > 0) { console.log(`[迅雷bootstrap] 🎯 页面上下文扫描完成：bearer=${foundBearer ? "已取到" : "无"} deviceId=${foundDid ? "已取到" : "无"} clientId=${foundClient ? "已取到" : "无"}`); console.log(`[迅雷bootstrap] 💡 captcha_token 将在您首次操作页面时（点开文件夹/刷新列表）由拦截器自动捕获。`); } else { console.warn(`[迅雷bootstrap] ⚠️ 页面上下文扫描未挖出任何 token。如果当前是已登录 pan.xunlei.com，请先点一下页面上的「刷新文件列表」或进入任意文件夹，触发一次官方 XHR，拦截器就能自动抓取。`); } return total; }, async getFilesInFolder(parentId, pathPrefix, onProgress) { const results = []; let pageToken = ""; const filters = encodeURIComponent(JSON.stringify({ phase: { eq: "PHASE_TYPE_COMPLETE" }, trashed: { eq: false }, })); do { const url = `${XUNLEI_API_BASE}/drive/v1/files?parent_id=${encodeURIComponent(parentId)}&usage=DISPLAY&filters=${filters}&with_audit=true&thumbnail_size=SIZE_SMALL&limit=100&page_token=${encodeURIComponent(pageToken)}`; const respText = await helper.get(url, this.getAuthHeaders()); const resp = JSON.parse(respText); const files = resp.files || []; for (const f of files) { if (f.kind === "drive#folder") { const subPath = pathPrefix ? `${pathPrefix}/${f.name}` : f.name; const subFiles = await this.getFilesInFolder(f.id, subPath, onProgress); results.push(...subFiles); } else { // 调试日志：打印迅雷文件对象的完整字段，确认是否有 cid 等秒传必需字段 if (!window._xunleiFileFieldsLogged) { window._xunleiFileFieldsLogged = true; console.log("[迅雷提取] 文件对象完整字段:", Object.keys(f), JSON.stringify(f).slice(0, 2000)); } const gcid = f.hash || f.gcid || ""; const filePath = pathPrefix ? `${pathPrefix}/${f.name}` : f.name; const entry = this._normalizeFileEntry(f, filePath, parentId); // 兜底：list接口没给cid/md5/etag时也保留条目，后面enrich阶段再补 if (!entry.gcid) entry.gcid = gcid; // 🔑 修复：2026-08 起 list 接口可能不再返回 hash/gcid，保留无 gcid 文件，后续用 detail 接口补全 if (!entry.gcid) { console.warn(`[迅雷提取] ⚠️ list接口未返回gcid，保留条目后续调detail补全: ${filePath} (id=${f.id})`); } results.push(entry); } } pageToken = resp.next_page_token || ""; if (onProgress) onProgress(results.length); } while (pageToken); return results; }, async collectFiles(selectedIds) { const store = this._getVueStore(); const driveAll = store?.state?.drive?.all || {}; const results = []; for (const id of selectedIds) { const f = driveAll[id]; if (!f) continue; if (f.kind === "drive#folder") { helper.updateLoadingMsg(`正在递归获取文件夹：${f.name}...`); const subFiles = await this.getFilesInFolder(f.id, f.name, (count) => { helper.updateLoadingMsg(`正在递归获取文件夹：${f.name}（已找到 ${count} 个文件）`); }); results.push(...subFiles); } else { const gcid = f.hash || f.gcid || ""; const entry = this._normalizeFileEntry(f, f.name, f.parentId); if (!entry.gcid) entry.gcid = gcid; // 🔑 修复：2026-08 list/store 可能缺失 hash/gcid，保留条目后续调 detail 补全 if (!entry.gcid) { console.warn(`[迅雷提取] ⚠️ store条目未返回gcid，保留后续调detail补全: ${f.name} (id=${f.id})`); } results.push(entry); } } return results; }, _getVueStore() { const el = document.querySelector("[class*='SourceListItem__item']"); return el?.__vue__?.$store || null; }, /** 获取当前文件夹名称 */ getCurrentFolderName() { try { const store = this._getVueStore(); if (store) { // 尝试从各种可能的位置取当前文件夹名 const name = store.state?.user?.currentFolder?.name || store.state?.source?.currentFolder?.name || store.state?.file?.currentFolder?.name || store.state?.user?.currentDir?.name || store.state?.source?.currentDirName || store.getters?.currentFolderName || ""; if (name) return String(name); } // 兜底：从页面标题取 const title = document.title || ""; const m = title.match(/^(.+?)[-_]/); if (m) return m[1].trim(); return title.trim(); } catch { return ""; } }, getSelectedIds() { const items = document.querySelectorAll("[class*='SourceListItem__item']"); for (const el of items) { const vue = el.__vue__; if (!vue) continue; const selected = vue.$props?.selected; if (Array.isArray(selected) && selected.length > 0) return selected; } return []; }, isSharePage() { return location.hostname === "pan.xunlei.com" && /^\/s\//.test(location.pathname); }, getShareId() { const m = location.pathname.match(/^\/s\/([^/?#]+)/); return m ? m[1] : ""; }, /** * 🔑 查找分享页 Vue store：多选择器兜底 + 全局 __vue__ 扫描 * 原选择器 [class*='Share__'] 在新版迅雷分享页可能不匹配任何元素 * 导致整个分享页提取链路断裂（passCodeToken/selectedIds/fileById 全部失效） */ _getShareStore() { // 1) 尝试多种可能的 class 名（迅雷不同版本分享页组件命名不同） const selectors = [ "[class*='Share__']", "[class*='sharePage']", "[class*='SharePage']", "[class*='ShareList']", "[class*='share-list']", "[class*='ShareHeader']", "[class*='share-header']", "[class*='ShareContent']", "[class*='share-content']", "[class*='SourceListItem']", "[class*='FileList']", "[class*='file-list']", "[class*='ListWrapper']", "[class*='App']", ]; for (const sel of selectors) { const el = document.querySelector(sel); if (el && el.__vue__) { const store = el.__vue__.$store || el.__vue__.$root?.$store || null; if (store) return store; } } // 2) 全局扫描：遍历所有带 __vue__ 的元素，找有 state.share 或 state.drive 模块的 store // 🔑 修复：迅雷改版后 class 名完全变化，不依赖任何 class 名，纯暴力扫描 const allEls = document.querySelectorAll("*"); let bestStore = null; let bestScore = 0; for (const el of allEls) { if (el.__vue__) { const store = el.__vue__.$store || el.__vue__.$root?.$store || null; if (store && store.state) { // 评分：优先选有 share 模块的 store let score = 0; if (store.state.share) score += 10; if (store.state.shareInfo) score += 8; if (store.state.sharePage) score += 8; if (store.state.drive) score += 5; if (store.state.files) score += 3; // 额外检查：是否存在 passCodeToken / shareId 等关键字段 const s = JSON.stringify(store.state); if (/pass[_-]?code[_-]?token/i.test(s)) score += 5; if (/share[_-]?id/i.test(s)) score += 3; if (score > bestScore) { bestScore = score; bestStore = store; } if (score >= 10) return store; // 足够好，直接返回 } } } if (bestStore) { console.log(`[迅雷分享] ✅ 全局扫描找到 Vue store（score=${bestScore}）`); return bestStore; } // 3) 终极兜底：从 window 对象里找可能的全局 store try { for (const k of Object.keys(window || {})) { try { const v = window[k]; if (v && typeof v === "object" && v.state && (v.state.share || v.state.drive || v.state.shareInfo)) { console.log(`[迅雷分享] ✅ 从 window.${k} 找到全局 store`); return v; } } catch {} } } catch {} return null; }, getPassCodeToken() { const store = this._getShareStore(); // 多种可能的 state 结构 const paths = [ store?.state?.share?.shareInfo?.passCodeToken, store?.state?.share?.passCodeToken, store?.state?.shareInfo?.passCodeToken, store?.state?.sharePage?.passCodeToken, store?.state?.share?.info?.passCodeToken, ]; for (const p of paths) { const s = String(p || "").trim(); if (s) return s; } return ""; }, /** * 🔑 独立从 DOM 获取勾选文件的名称列表（与 ID 获取解耦） * 无论从哪一层获取 ID，都用此方法获取文件名做交叉验证 */ _getShareCheckedNamesFromDOM() { const checkedNames = []; document.querySelectorAll("input[type='checkbox']:checked").forEach(cb => { if (cb.closest("thead, th, [class*='header' i]")) return; if (cb.closest("[class*='SelectAll'], [class*='select-all']")) return; let el = cb.parentElement; for (let i = 0; i < 20 && el; i++) { const vue = el.__vue__; if (vue) { // 从 Vue props/data 提取文件名 const nameCandidates = [ vue.$props?.file?.name, vue.$props?.name, vue.$props?.fileName, vue.$data?.file?.name, vue.$data?.name, vue.$data?.fileName, vue.$props?.item?.name, vue.$data?.item?.name, vue.$props?.file_name, vue.$data?.file_name, ]; for (const n of nameCandidates) { const s = String(n || "").trim(); if (s && s.length > 1) { checkedNames.push(s); return; // 找到一个就停 } } } // 兜底：从文本节点或子元素获取文件名 const textSelectors = ["[class*='name']", "[class*='Name']", "[class*='title']", "span", "div"]; for (const sel of textSelectors) { const parts = el.querySelectorAll(sel); for (const p of parts) { const txt = (p.textContent || "").trim(); if (txt && txt.length > 1 && txt.length < 200 && !/^[\s\d]+$/.test(txt)) { checkedNames.push(txt); return; } } } el = el.parentElement; } // 最终兜底：尝试从 checkbox 附近的文本获取 if (el) { const rowText = (el.textContent || "").trim(); if (rowText && rowText.length > 1 && rowText.length < 200) { // 尝试提取第一个看起来像文件名的部分 const match = rowText.match(/[^\s]+[\.\u4e00-\u9fa5a-zA-Z0-9-]+/); if (match) { checkedNames.push(match[0]); return; } } } }); return checkedNames; }, /** * 🔑 获取分享页勾选的文件 ID 列表 * 核心策略：DOM 提取优先（ID+名称来自同一源，保证一致性），Vue store 兜底 */ getShareSelectedIds() { // ---- 第零层：DOM 优先 —— 从勾选框直接提取 ID+名称（最可靠）---- const domResult = this._extractIdsAndNamesFromDOM(); if (domResult.ids.length > 0) { // DOM 提取成功：ID 和名称来自同一来源，完全可靠 this._lastCheckedNames = domResult.names; console.log(`[迅雷分享] DOM提取成功 ${domResult.ids.length} 个文件（ID与名称配对一致）`); return domResult.ids; } // ---- DOM 失败：回退到 Vue store ---- const store = this._getShareStore(); const domNames = this._getShareCheckedNamesFromDOM(); // ---- 第一层：从 Vue store 直接读勾选 ID ---- if (store) { const statePaths = [store.state?.share, store.state?.shareInfo, store.state?.sharePage]; for (const share of statePaths) { if (!share) continue; for (const key of ["checkedFileIds", "selectedFileIds", "selectedIds", "checkedIds", "selected", "fileIds", "checked"]) { const v = share[key]; if (Array.isArray(v) && v.length > 0 && v.every(x => typeof x === "string" || typeof x === "number")) { const ids = v.map(String); if (domNames.length > 0) this._lastCheckedNames = domNames; console.log(`[迅雷分享] VueStore第一层提取 ${ids.length} 个ID`); return ids; } } } const shareInfo = store.state?.share?.shareInfo || store.state?.shareInfo; if (shareInfo) { for (const key of ["checkedFileIds", "selectedFileIds", "selectedIds", "checkedIds", "selected"]) { const v = shareInfo[key]; if (Array.isArray(v) && v.length > 0) { const ids = v.map(String); if (domNames.length > 0) this._lastCheckedNames = domNames; console.log(`[迅雷分享] VueStore shareInfo提取 ${ids.length} 个ID`); return ids; } } } } // ---- 第二层：从 store 的 fileList + DOM 勾选框索引匹配 ---- const share = store?.state?.share || store?.state?.shareInfo || store?.state?.sharePage; if (share) { const listIds = share.list || share.fileList || share.filesOrder || []; const idList = Array.isArray(listIds) ? listIds.map(x => typeof x === "string" || typeof x === "number" ? String(x) : String(x?.id || "")).filter(Boolean) : []; if (idList.length > 0) { const rowCheckboxes = Array.from(document.querySelectorAll("input[type='checkbox']")).filter(cb => { if (cb.closest("thead, th, [class*='header' i], [class*='Header']")) return false; if (cb.getAttribute("aria-label") === "Select all") return false; if (cb.closest("[class*='SelectAll'], [class*='select-all']")) return false; return true; }); if (rowCheckboxes.length > 0) { const checkedIds = []; rowCheckboxes.forEach((cb, idx) => { if (cb.checked && idx < idList.length) checkedIds.push(String(idList[idx])); }); if (checkedIds.length > 0) { if (domNames.length > 0) this._lastCheckedNames = domNames; console.log(`[迅雷分享] VueStore第二层(索引匹配)提取 ${checkedIds.length} 个ID`); return checkedIds; } } } } // ---- 最终兜底：返回 DOM 提取的 ID（可能为空）---- this._lastCheckedNames = domNames; // 🔑 修复：当所有提取方式都失败，但检测到页面有勾选框时， // 用 getAllFilesIds() 返回当前目录所有文件 ID 作为兜底（用户确实勾选了，只是读不到状态） if (domResult.ids.length === 0 && this._hasCheckedCheckboxes()) { console.warn("[迅雷分享] ⚠️ 所有ID提取方式均失败，但检测到有勾选操作 → 启用 getAllFilesIds 兜底（返回目录全部文件）"); const allIds = this.getAllFilesIds(); if (allIds.length > 0) { console.log(`[迅雷分享] ✅ 兜底成功：返回全部 ${allIds.length} 个文件 ID`); return allIds; } } console.warn("[迅雷分享] 所有ID提取方式均失败"); return []; }, /** * 🔑 从 DOM 直接提取勾选文件的 ID 和名称（配对一致） * 遍历每个勾选框，从同一 Vue 组件中提取 ID 和名称 * 只有当 ID 找到时才会加入结果，保证 ID 和名称一一对应 */ _extractIdsAndNamesFromDOM() { const ids = []; const names = []; document.querySelectorAll("input[type='checkbox']:checked").forEach(cb => { if (cb.closest("thead, th, [class*='header' i]")) return; if (cb.closest("[class*='SelectAll'], [class*='select-all']")) return; let el = cb.parentElement; let foundId = ""; let foundName = ""; for (let i = 0; i < 20 && el; i++) { const vue = el.__vue__; if (vue) { // 从同一 Vue 组件提取 ID const idCandidates = [ vue.$props?.file?.id, vue.$props?.id, vue.$props?.fileId, vue.$data?.file?.id, vue.$data?.id, vue.$data?.fileId, vue.$props?.item?.id, vue.$data?.item?.id, vue.$props?.resId, vue.$data?.resId, ]; for (const c of idCandidates) { const s = String(c || "").trim(); if (s && /^[A-Za-z0-9_-]+$/.test(s) && s.length > 5) { foundId = s; break; } } // 从同一 Vue 组件提取名称 const nameCandidates = [ vue.$props?.file?.name, vue.$props?.name, vue.$props?.fileName, vue.$data?.file?.name, vue.$data?.name, vue.$data?.fileName, vue.$props?.item?.name, vue.$data?.item?.name, vue.$props?.file_name, vue.$data?.file_name, vue.$props?.title, vue.$data?.title, ]; for (const n of nameCandidates) { const s = String(n || "").trim(); if (s && s.length > 1) { foundName = s; break; } } if (foundId) break; } // data 属性兜底 if (!foundId) { const dataAttrs = ["data-id", "data-fileid", "data-file-id", "data-fid", "data-resid"]; for (const attr of dataAttrs) { const val = el.getAttribute(attr) || el.dataset?.id || el.dataset?.fileId; const s = String(val || "").trim(); if (s && /^[A-Za-z0-9_-]+$/.test(s) && s.length > 5) { foundId = s; break; } } } if (foundId) break; el = el.parentElement; } if (foundId) { ids.push(foundId); // 只在找到名称时才加入，保持 ID 和名称一一对应 if (foundName) { names.push(foundName); } } }); return { ids, names }; }, /** * 🔑 兜底方法：获取当前页面所有可见文件的 ID 列表 * 当 checkedFileIds 始终为空时（Vue 结构变更导致）， * 检测到页面上有已勾选的 checkbox 时，直接返回所有文件 ID 作为兜底。 * 适用场景：用户勾选了文件，但脚本无法从 Vue store 或 DOM 中读取勾选状态 */ getAllFilesIds() { const ids = []; const names = []; // 方案1：从 Vue store 的 fileList / list / files 中拿所有 ID const store = this._getShareStore(); if (store) { const statePaths = [store.state?.share, store.state?.shareInfo, store.state?.sharePage, store.state?.drive]; for (const share of statePaths) { if (!share) continue; const listArr = share.list || share.fileList || share.files || share.items || share.filesOrder || []; if (Array.isArray(listArr)) { for (const item of listArr) { if (!item) continue; const id = String(item.id || item.fileId || item.res_id || "").trim(); const name = String(item.name || item.fileName || item.file_name || "").trim(); if (id && /^[A-Za-z0-9_-]+$/.test(id) && id.length > 5) { ids.push(id); if (name) names.push(name); } } } // 从 filesMap / fileMap 取所有值 const mapObj = share.files || share.fileMap || share.filesMap || share.fileMapData; if (mapObj && typeof mapObj === "object" && !Array.isArray(mapObj)) { for (const k of Object.keys(mapObj)) { const item = mapObj[k]; if (!item) continue; const id = String(item.id || item.fileId || "").trim(); const name = String(item.name || item.fileName || "").trim(); if (id && /^[A-Za-z0-9_-]+$/.test(id) && id.length > 5 && !ids.includes(id)) { ids.push(id); if (name && !names.includes(name)) names.push(name); } } } } } // 方案2：从 DOM 遍历所有 Vue 组件拿 file.id（不依赖勾选状态） if (ids.length === 0) { const allEls = document.querySelectorAll("*"); for (const el of allEls) { if (el.__vue__) { const v = el.__vue__; const tryVals = [ v.$props?.file, v.$data?.file, v.$props?.item, v.$data?.item, v.$props, v.$data, ]; for (const obj of tryVals) { if (!obj || typeof obj !== "object") continue; const id = String(obj.id || obj.fileId || obj.resId || "").trim(); const name = String(obj.name || obj.fileName || obj.file_name || obj.title || "").trim(); if (id && /^[A-Za-z0-9_-]+$/.test(id) && id.length > 5 && !ids.includes(id)) { ids.push(id); if (name && !names.includes(name)) names.push(name); } } } } } // 保存名称供后续使用 if (names.length > 0) this._lastCheckedNames = names; if (ids.length > 0) { console.log(`[迅雷分享] ✅ getAllFilesIds 兜底：找到 ${ids.length} 个文件 ID（作为勾选兜底）`); } return ids; }, /** * 🔑 检测页面上是否有已勾选的 checkbox（排除表头全选框） */ _hasCheckedCheckboxes() { const cbs = document.querySelectorAll("input[type='checkbox']:checked"); for (const cb of cbs) { if (cb.closest("thead, th, [class*='header' i], [class*='Header']")) continue; if (cb.closest("[class*='SelectAll'], [class*='select-all']")) continue; if (cb.getAttribute("aria-label") === "Select all") continue; return true; } // 也检查自定义伪复选框（图标对号） const pseudoChecks = document.querySelectorAll("[class*='checked' i], [class*='selected' i], [aria-checked='true']"); for (const pc of pseudoChecks) { if (pc.closest("thead, th, [class*='header' i]")) continue; if (/全选|select.?all/i.test(pc.textContent || "")) continue; const txt = (pc.textContent || "").trim(); if (txt.length > 200) continue; // 太长的不是勾选图标 // 检测对号图标类名 if (/checkbox|check|✔|✓|对号|勾选|已选/i.test((pc.className || "") + " " + txt)) { return true; } } return false; }, /** * 🔑 从 Vue store 按 ID 查找文件对象 * 改进：多种 state 路径 + 多种文件映射结构 */ getShareFileById(id) { const store = this._getShareStore(); if (!store) return null; const statePaths = [store.state?.share, store.state?.shareInfo, store.state?.sharePage]; for (const share of statePaths) { if (!share) continue; // 尝试多种映射结构 const filesMap = share.files || share.fileMap || share.filesMap || share.fileMapData; if (filesMap && typeof filesMap === "object" && !Array.isArray(filesMap)) { const found = filesMap[id] || filesMap[String(id)]; if (found) return found; } // 尝试数组结构 const arr = share.fileList || share.files || share.list || share.items; if (Array.isArray(arr)) { const found = arr.find(f => String(f?.id ?? f?.fileId ?? "") === String(id)); if (found) return found; } } return null; }, async _fetchShareRootFiles(shareId, passCodeToken) { // 🔑 分享页必须用匿名头（不带 Bearer），否则访问他人分享会 401/403 // usage=CONSUME 让 API 返回下载链接（web_content_link / links） const url = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=100&with_audit=true&thumbnail_size=SIZE_LARGE&usage=CONSUME`; const respText = await helper.get(url, this._getShareAnonymousHeaders()); const resp = JSON.parse(respText); return resp.files || resp.data?.files || resp.data?.items || []; }, /** * 🔑 按文件名在分享中搜索文件（不做 gcid 过滤，用于名称兜底匹配） * 与 getShareFilesInFolder 不同：此方法只做名称搜索，不过滤文件 */ async _searchShareFileByName(shareId, passCodeToken, expectedName) { // 先获取根目录文件 const rootFiles = await this._fetchShareRootFiles(shareId, passCodeToken); const matchName = (fn) => { const n = String(fn?.name || fn?.fileName || fn?.file_name || "").trim(); if (!n) return false; return n === expectedName || n.includes(expectedName) || expectedName.includes(n); }; // 先在根目录找 let found = rootFiles.find(matchName); if (found) return found; // 递归搜索子目录 for (const rf of rootFiles) { if (rf.kind === "drive#folder") { try { const subFiles = await this._fetchAllShareFilesRecursive(shareId, rf.id, passCodeToken); found = subFiles.find(matchName); if (found) return found; } catch {} } } return null; }, /** * 🔑 递归获取指定文件夹下所有文件（不过滤 gcid，返回原始 API 对象） */ async _fetchAllShareFilesRecursive(shareId, parentId, passCodeToken) { const results = []; let pageToken = ""; do { const url = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=${encodeURIComponent(parentId)}&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=100&page_token=${encodeURIComponent(pageToken)}&with_audit=true&thumbnail_size=SIZE_LARGE&usage=CONSUME`; const respText = await helper.get(url, this._getShareAnonymousHeaders()); const resp = JSON.parse(respText); const files = resp.files || resp.data?.files || []; for (const f of files) { if (f.kind === "drive#folder") { const subFiles = await this._fetchAllShareFilesRecursive(shareId, f.id, passCodeToken); results.push(...subFiles); } else { results.push(f); } } pageToken = resp.next_page_token || ""; } while (pageToken); return results; }, async getShareFilesInFolder(shareId, parentId, passCodeToken, pathPrefix, onProgress) { const results = []; let pageToken = ""; do { // 🔑 同_fetchShareRootFiles：匿名头 + usage=CONSUME 才能拿到 downloadUrl const url = `${XUNLEI_API_BASE}/drive/v1/share/detail?share_id=${encodeURIComponent(shareId)}&parent_id=${encodeURIComponent(parentId)}&pass_code_token=${encodeURIComponent(passCodeToken)}&limit=100&page_token=${encodeURIComponent(pageToken)}&with_audit=true&thumbnail_size=SIZE_LARGE&usage=CONSUME`; const respText = await helper.get(url, this._getShareAnonymousHeaders()); const resp = JSON.parse(respText); const files = resp.files || []; for (const f of files) { if (f.kind === "drive#folder") { const subPath = pathPrefix ? `${pathPrefix}/${f.name}` : f.name; const subFiles = await this.getShareFilesInFolder(shareId, f.id, passCodeToken, subPath, onProgress); results.push(...subFiles); } else { const gcid = f.hash || f.gcid || ""; const filePath = pathPrefix ? `${pathPrefix}/${f.name}` : f.name; const entry = this._normalizeFileEntry(f, filePath, parentId); if (!entry.gcid) entry.gcid = gcid; // 🔑 修复：分享页list也可能缺失hash/gcid，保留后续调detail补全 if (!entry.gcid) { console.warn(`[迅雷分享提取] ⚠️ list接口未返回gcid，保留条目后续调detail补全: ${filePath} (id=${f.id})`); } results.push(entry); } } pageToken = resp.next_page_token || ""; if (onProgress) onProgress(results.length); } while (pageToken); return results; }, injectButton() { if (document.getElementById(BTN_XUNLEI_JSON_ID)) return; const btn = document.createElement("button"); btn.id = BTN_XUNLEI_JSON_ID; btn.type = "button"; btn.style.cssText = "box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;" + "height:36px;min-height:36px;padding:0 12px;margin-left:8px;" + "border-radius:4px;white-space:nowrap;cursor:pointer;vertical-align:middle;" + "background:#ff9800 !important;border:1px solid #ff9800 !important;color:#fff !important;" + "font-size:13px;line-height:1.45;font-weight:500;" + "font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",Roboto,\"Helvetica Neue\",Arial," + "\"PingFang SC\",\"Hiragino Sans GB\",\"Microsoft YaHei\",sans-serif;"; const span = document.createElement("span"); span.textContent = "提取JSON"; span.style.cssText = "font-size:13px;line-height:1.45;font-weight:500;"; btn.appendChild(span); const setLabel = (t) => { span.textContent = t; }; btn.onclick = async () => { try { btn.disabled = true; setLabel("生成中..."); await generateXunlei(); setLabel("提取JSON"); } catch (e) { alert(e?.message || "生成失败"); setLabel("提取JSON"); } finally { btn.disabled = false; } }; const tryInsert = () => { if (document.getElementById(BTN_XUNLEI_JSON_ID)) return true; const menu = document.querySelector("[class*='FileMenu__menu']"); if (!menu) return false; const primaryItem = menu.querySelector("[class*='FileMenu__item'][class*='primary'], [class*='FileMenu__item--'][class*='primary']"); menu.insertBefore(btn, primaryItem || menu.firstChild); return true; }; if (tryInsert()) return; const observer = new MutationObserver(() => { if (tryInsert()) observer.disconnect(); }); observer.observe(document.body, { childList: true, subtree: true }); setTimeout(() => { if (document.getElementById(BTN_XUNLEI_JSON_ID)) return; observer.disconnect(); btn.style.cssText += "position:fixed;right:24px;top:70px;z-index:2147483647;" + "box-shadow:0 4px 18px rgba(255,152,0,.5),0 2px 8px rgba(0,0,0,.18);"; document.body.appendChild(btn); }, 8000); }, injectShareButton() { if (document.getElementById(BTN_XUNLEI_SHARE_JSON_ID)) return; const btn = document.createElement("button"); btn.id = BTN_XUNLEI_SHARE_JSON_ID; btn.type = "button"; btn.style.cssText = "box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;" + "height:36px;padding:0 12px;margin-right:8px;" + "border-radius:4px;white-space:nowrap;cursor:pointer;vertical-align:middle;" + "background:#ff9800 !important;border:1px solid #ff9800 !important;color:#fff !important;" + "font-size:13px;line-height:1.45;font-weight:500;" + "font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",Roboto,\"Helvetica Neue\",Arial," + "\"PingFang SC\",\"Hiragino Sans GB\",\"Microsoft YaHei\",sans-serif;"; const span = document.createElement("span"); span.textContent = "提取JSON"; span.style.cssText = "font-size:13px;line-height:1.45;font-weight:500;"; btn.appendChild(span); const setLabel = (t) => { span.textContent = t; }; btn.onclick = async () => { try { btn.disabled = true; setLabel("生成中..."); await generateXunleiShare(); setLabel("提取JSON"); } catch (e) { alert(e?.message || "生成失败"); setLabel("提取JSON"); } finally { btn.disabled = false; } }; const tryInsert = () => { if (document.getElementById(BTN_XUNLEI_SHARE_JSON_ID)) return true; // 🔑 2026-08 修复：精确注入到分享内容区域，避免匹配到顶部导航栏 // 目标：在"复制分享链接"按钮之前插入（搜索框右侧） // 关键：必须验证锚点在分享内容区域内，而不是顶部 header // 收集页面上所有 button/可点击元素 const allButtons = document.querySelectorAll("button, [role='button'], .td-button"); let anchor = null; // 遍历所有按钮，找"复制分享链接" // 必须确认该按钮在分享内容区域（class 包含 share 相关） for (const el of allButtons) { const text = (el.textContent || "").replace(/\s+/g, "").trim(); if (/^复制分享链接$/.test(text) || /^复制链接$/.test(text)) { // 验证：父级或祖先是否有 share 相关 class let node = el; let valid = false; for (let i = 0; i < 8 && node; i++) { const cls = (node.className || "").toString().toLowerCase(); const id = (node.id || "").toString().toLowerCase(); const dataAttrs = (node.getAttribute?.("data-testid") || "").toString().toLowerCase(); if (/share|sharecontent|shareheader|sharetoolbar|sharedetail|sharefile/i.test(cls + " " + id + " " + dataAttrs)) { valid = true; break; } // 排除 header / topbar / navbar if (/topbar|navbar|appheader|app-header|mainheader/i.test(cls + " " + id)) { break; } node = node.parentElement; } if (valid) { anchor = el; break; } } } // 如果没精确匹配，退而求其次：用 class 选择器 if (!anchor) { const copyBtn = document.querySelector("[class*='shareToolbarBtn']"); if (copyBtn) { // 验证不在顶部 header let node = copyBtn; let inShareArea = false; for (let i = 0; i < 6 && node; i++) { const cls = (node.className || "").toString().toLowerCase(); if (/share/i.test(cls)) { inShareArea = true; break; } if (/topbar|navbar|header/i.test(cls) && !/share/i.test(cls)) break; node = node.parentElement; } if (inShareArea) anchor = copyBtn; } } if (anchor && anchor.parentNode) { anchor.parentNode.insertBefore(btn, anchor); return true; } // 最后兜底：找搜索框，在它后面插入 const searchInput = document.querySelector("input[name='share_file_search']"); if (searchInput) { // 找到搜索框的容器（向上找2-3层） let container = searchInput; for (let i = 0; i < 4 && container; i++) { container = container.parentElement; if (!container) break; const cls = (container.className || "").toString().toLowerCase(); if (/share|toolbar|search|filelist/i.test(cls)) break; } if (container && container.parentNode) { container.parentNode.insertBefore(btn, container.nextSibling); return true; } } return false; }; if (tryInsert()) return; const observer = new MutationObserver(() => { if (tryInsert()) observer.disconnect(); }); observer.observe(document.body, { childList: true, subtree: true }); setTimeout(() => { if (document.getElementById(BTN_XUNLEI_SHARE_JSON_ID)) return; observer.disconnect(); btn.style.cssText += "position:fixed;right:24px;top:70px;z-index:2147483647;" + "box-shadow:0 4px 18px rgba(255,152,0,.5),0 2px 8px rgba(0,0,0,.18);"; document.body.appendChild(btn); }, 8000); }, }; async function generateXunlei() { if (!panXunlei._cachedToken) { throw new Error( "未检测到迅雷云盘登录态（Bearer token）。\n" + "请在已登录状态下，先点击一次文件列表（触发API请求），再点击『提取秒传JSON』。" ); } // 🔑 captcha_token 检查：必须在提取时刻才检查（bootstrap 阶段还没触发 XHR，肯定是空的） const captchaToken = panXunlei._getPersistentCaptchaToken(); if (!captchaToken) { throw new Error( "未检测到 captcha_token（反验证码令牌）。\n\n" + "原因：captcha_token 是实时生成的，必须通过拦截器捕获官方 API 请求才能获取。\n\n" + "解决步骤：\n" + "1. 在当前迅雷页面上点击任意文件夹或刷新文件列表\n" + "2. 等待控制台出现「✅ XHR 捕获 captcha_token」的日志\n" + "3. 再点击『提取秒传JSON』按钮" ); } console.log(`[迅雷提取] ✅ captcha_token 检查通过（长度=${captchaToken.length}），继续提取...`); const selectedIds = panXunlei.getSelectedIds(); if (!selectedIds.length) { throw new Error("请先勾选要导出的文件或文件夹，再点击『提取秒传JSON』。"); } helper.showLoadingDialog("正在生成迅雷秒传 JSON", "正在获取文件信息..."); try { const files = await panXunlei.collectFiles(selectedIds); if (!files.length) { throw new Error("所选项中没有可导出的文件（文件夹为空或没有选中文件）。"); } // 极速模式：先不补 cid/md5/downloadUrl；允许对缺 gcid 的条目调 getFileDetail 补全 // 若 detail 也不返回 gcid，则通过 downloadUrl 下载 3×20KB 样本计算 tripleCid 作为 gcid await panXunlei.enrichEntriesMissingHashes(files, (done, total, e) => { helper.updateLoadingMsg(`极速校验条目：${done}/${total}（${String(e.path || "").slice(0, 50)}）`); }, null, { allowDetailFetch: true, allowSampleCompute: true }); // 补全后仍缺 gcid 的条目过滤掉，并给出明确提示 const filesWithGcid = files.filter(x => x && /^[0-9A-Fa-f]{40}$/.test(String(x.gcid || ""))); if (!filesWithGcid.length) { throw new Error("所选项中没有可导出的文件（文件没有 gcid，detail 接口也未返回）。\n请确认文件已上传完成，或尝试刷新页面后重新勾选。"); } if (filesWithGcid.length < files.length) { console.warn(`[迅雷提取] ⚠️ ${files.length - filesWithGcid.length} 个文件无法获取 gcid，已自动过滤`); } // 迅雷主站：sourceTag=xunlei // 即使在主站，也尝试获取 shareId/passCodeToken（可能用户从分享页跳转过来，或页面有分享上下文） // 导入端在 downloadUrl 过期时可用来重新获取下载链接 const xunleiExtras = {}; const trySid = panXunlei.getShareId(); if (trySid) xunleiExtras.shareId = trySid; const tryPct = panXunlei.getPassCodeToken(); if (tryPct) xunleiExtras.passCodeToken = tryPct; const jsonData = helper.makeJson(filesWithGcid, "xunlei", Object.keys(xunleiExtras).length ? xunleiExtras : null); helper.closeLoadingDialog(); const curName = panXunlei.getCurrentFolderName(); const baseName = inferExportBaseName(filesWithGcid, curName); helper.showResultDialog(jsonData, "", true, baseName); } catch (e) { helper.closeLoadingDialog(); throw e; } } async function generateXunleiShare() { if (!panXunlei._cachedCaptchaToken && !panXunlei._cachedToken) { throw new Error( "未检测到迅雷云盘访问凭证。\n" + "请刷新页面，输入提取码后等待文件列表加载完成，再点击『提取秒传JSON』。" ); } // 🔑 captcha_token 检查（分享页同样需要） const captchaToken = panXunlei._getPersistentCaptchaToken(); if (!captchaToken) { throw new Error( "未检测到 captcha_token（反验证码令牌）。\n\n" + "解决步骤：\n" + "1. 刷新当前分享页，重新输入提取码\n" + "2. 等待文件列表加载完成（此时拦截器会捕获 captcha_token）\n" + "3. 再点击『提取秒传JSON』按钮" ); } const shareId = panXunlei.getShareId(); if (!shareId) throw new Error("无法解析分享 ID。"); const passCodeToken = panXunlei.getPassCodeToken(); if (!passCodeToken) throw new Error("未获取到 pass_code_token，请等待页面加载完成后重试。"); const selectedIds = panXunlei.getShareSelectedIds(); if (!selectedIds.length) { throw new Error("请先勾选要导出的文件或文件夹，再点击『提取秒传JSON』。"); } helper.showLoadingDialog("正在生成迅雷分享秒传 JSON", "正在获取文件信息..."); try { const results = []; let rootFiles = null; // 🔑 关键修复：实时从 DOM 获取最新的文件名（不依赖缓存） const expectedNames = panXunlei._getShareCheckedNamesFromDOM(); // 如果 DOM 获取失败，回退到缓存 const finalNames = expectedNames.length > 0 ? expectedNames : (panXunlei._lastCheckedNames || []); let nameIdx = 0; for (const id of selectedIds) { let f = panXunlei.getShareFileById(id); let idValid = true; // 标记 ID 映射是否有效 // 🔑 名称交叉验证：用 DOM 获取的文件名验证 ID 映射 if (finalNames.length > 0 && nameIdx < finalNames.length) { const expectedName = finalNames[nameIdx]; if (f) { const actualName = String(f?.name || f?.fileName || f?.file_name || "").trim(); const actualBase = actualName.split(/[\\/]/).pop() || actualName; // 严格验证：检查文件名是否匹配 if (expectedName && actualBase) { const matchEx = expectedName === actualBase || expectedName.includes(actualBase) || actualBase.includes(expectedName); // 扩展名也检查（如果有的话） const expExt = (expectedName.match(/\.[^.]+$/) || [""])[0]; const actExt = (actualBase.match(/\.[^.]+$/) || [""])[0]; const extMatch = !expExt || !actExt || expExt.toLowerCase() === actExt.toLowerCase(); if (!matchEx || !extMatch) { console.warn(`[迅雷分享] ⚠️ ID映射错位：期望="${expectedName}" 实际="${actualBase}"`); f = null; // 标记为失效 idValid = false; } } } } // ID 查找失败或验证失败 → 用名称兜底搜索 if (!f) { // 如果 ID 验证有效，先尝试用 ID 在 rootFiles 中查找（仅第一次需要） if (idValid) { if (!rootFiles) rootFiles = await panXunlei._fetchShareRootFiles(shareId, passCodeToken); f = rootFiles.find(x => String(x.id) === String(id)) || null; } // 🔑 关键修复：使用 _searchShareFileByName 做纯名称搜索 // 此方法不做 gcid 过滤，能找到所有文件 if (!f && finalNames.length > 0 && nameIdx < finalNames.length) { const expectedName = finalNames[nameIdx]; console.log(`[迅雷分享] 🔍 开始按名称搜索："${expectedName}"`); try { f = await panXunlei._searchShareFileByName(shareId, passCodeToken, expectedName); if (f) { console.log(`[迅雷分享] ✅ 名称匹配成功："${expectedName}" → "${f.name || f.fileName}"`); } else { console.warn(`[迅雷分享] ⚠️ 名称搜索也失败："${expectedName}"（API未返回此文件）`); } } catch (e) { console.warn(`[迅雷分享] ⚠️ 名称搜索异常：${e.message}`); } } } if (!f) continue; if (finalNames.length > 0) nameIdx++; // 只有成功找到文件才推进名称索引 if (f.kind === "drive#folder") { helper.updateLoadingMsg(`正在递归获取文件夹：${f.name}...`); const subFiles = await panXunlei.getShareFilesInFolder( shareId, f.id, passCodeToken, f.name, (count) => helper.updateLoadingMsg(`正在递归获取文件夹：${f.name}（已找到 ${count} 个文件）`) ); results.push(...subFiles); } else { const gcid = f.hash || f.gcid || ""; const entry = panXunlei._normalizeFileEntry(f, f.name, f.parentId); if (!entry.gcid) entry.gcid = gcid; // 🔑 修复：2026-08 分享页store/list可能缺失hash/gcid，保留后续调detail补全 if (!entry.gcid) { console.warn(`[迅雷分享提取] ⚠️ 分享页条目未返回gcid，保留后续调detail补全: ${f.name} (id=${f.id})`); } results.push(entry); } } if (!results.length) throw new Error("没有可导出的文件（未找到任何选中文件）。"); const store = panXunlei._getShareStore(); const shareTitle = store?.state?.share?.shareInfo?.params?.title || store?.state?.share?.shareInfo?.title || ""; // 极速模式：分享页也跳过 cid/md5/downloadUrl 补全；允许对缺 gcid 的条目调 getFileDetail 补全 // 若 detail 也不返回 gcid，则通过 downloadUrl 下载 3×20KB 样本计算 tripleCid 作为 gcid await panXunlei.enrichEntriesMissingHashes(results, (done, total, e) => { helper.updateLoadingMsg(`极速校验条目：${done}/${total}（${String(e.path || "").slice(0, 50)}）`); }, { shareId, passCodeToken }, { allowDetailFetch: true, allowSampleCompute: true }); // 补全后仍缺 gcid 的条目过滤掉 const resultsWithGcid = results.filter(x => x && /^[0-9A-Fa-f]{40}$/.test(String(x.gcid || ""))); if (!resultsWithGcid.length) { throw new Error("没有可导出的文件（文件没有 gcid，detail 接口也未返回）。\n请确认文件已上传完成，或尝试刷新页面后重新勾选。"); } if (resultsWithGcid.length < results.length) { console.warn(`[迅雷分享提取] ⚠️ ${results.length - resultsWithGcid.length} 个文件无法获取 gcid，已自动过滤`); } // 迅雷分享页：写入 sourceTag=xunlei，同时行级注入 shareId + passCodeToken， // 这样导入端即使分享链接过期，仍能尝试重新调迅雷接口（或者导入端识别为迅雷源不再错调光鸭 helper） const jsonData = helper.makeJson(resultsWithGcid, "xunlei", { shareId, passCodeToken }); helper.closeLoadingDialog(); // 分享页面：优先用 shareTitle 作为基础名 const baseName = inferExportBaseName(resultsWithGcid, shareTitle); helper.showResultDialog(jsonData, shareTitle, true, baseName); } catch (e) { helper.closeLoadingDialog(); throw e; } } // ============================================================ // 光鸭云盘：access_token + 导入秒传 JSON + 提取秒传 JSON // ============================================================ const panGuangya = { isHost() { const h = location.hostname; return h === "guangyapan.com" || h.endsWith(".guangyapan.com"); }, /** * 🔑 从 URL hash 中解析当前所在目录的 ID（支持嵌套路径） * URL 格式：#home/all/{folderId}-{name}/{subId}-{name}/... * 提取最后一个 {numericId} 作为当前目录 ID */ _parseFolderIdFromUrl() { try { const hash = location.hash.replace(/^#/, ""); const qIdx = hash.indexOf("?"); const pathPart = qIdx >= 0 ? hash.slice(0, qIdx) : hash; const parts = pathPart.split("/").filter(Boolean); if (!parts.length) return ""; // 已知的路由名称（非目录ID） const knownRoutes = new Set(["home", "all", "video", "image", "audio", "file", "recent", "favorite", "share", "trash", "recycle"]); // 从后往前找最后一个包含数字前缀的段（格式：{numericId}-{name}） for (let i = parts.length - 1; i >= 0; i--) { const seg = parts[i]; if (knownRoutes.has(seg.toLowerCase())) continue; // 匹配 {数字}-{名称} 格式，如 "1891452836117372938-影视" const m = seg.match(/^(\d+)-(.+)$/); if (m) return m[1]; // 纯数字格式（无后缀） if (/^\d+$/.test(seg)) return seg; // 如果段不是已知路由也不是数字开头，继续往前找 } return ""; } catch { return ""; } }, /** 从当前页面真实请求（拦截器捕获优先）+ URL hash 提取当前所在目录的 ID */ getCurrentFolderId() { try { // 🔑 关键修复：优先使用 URL 解析（始终反映当前页面状态），而非可能过期的拦截器缓存 const urlFolderId = this._parseFolderIdFromUrl(); if (urlFolderId) return urlFolderId; // URL 无法解析时（如根目录），回退到拦截器缓存 if (panGuangya._cachedListUrlTemplate) { const captured = panGuangya._extractParentIdFromCapturedRequest() || ""; if (captured) return captured; } // 从缓存的文件列表反推 parentId if (panGuangya._cachedCurrentList && panGuangya._cachedCurrentList.length > 0) { const first = panGuangya._cachedCurrentList[0]; const fromList = String(first?.parentId || first?.parent_id || first?.dirId || first?.dir_id || ""); if (fromList) return fromList; } // 最后：URL query 参数 const hash = location.hash.replace(/^#/, ""); const qIdx = hash.indexOf("?"); const queryPart = qIdx >= 0 ? hash.slice(qIdx + 1) : ""; const params = new URLSearchParams(queryPart); for (const key of ["folderId", "folder_id", "dirId", "dir_id", "parentId", "parent_id", "fid", "id"]) { const v = params.get(key); if (v) return v; } return ""; } catch { return ""; } }, /** 获取当前文件夹名称（从 URL hash 的最后一段中提取，去掉ID前缀） */ getCurrentFolderName() { try { const hash = location.hash.replace(/^#/, ""); const qIdx = hash.indexOf("?"); const pathPart = qIdx >= 0 ? hash.slice(0, qIdx) : hash; const parts = pathPart.split("/").filter(Boolean); if (!parts.length) return ""; const knownRoutes = new Set(["home", "all", "video", "image", "audio", "file", "recent", "favorite", "share", "trash", "recycle"]); // 从后往前找最后一个包含名称的段 for (let i = parts.length - 1; i >= 0; i--) { const seg = parts[i]; if (knownRoutes.has(seg.toLowerCase())) continue; const m = seg.match(/^(\d+)-(.+)$/); if (m) return decodeURIComponent(m[2]); if (!/^\d+$/.test(seg)) return decodeURIComponent(seg); } return "根目录"; } catch { return ""; } }, pickTokenFromPageStorage() { const storages = [localStorage, sessionStorage]; for (const st of storages) { try { for (let i = 0; i < st.length; i++) { const k = st.key(i); if (!k) continue; const v = st.getItem(k); if (!v || v.length > 60000) continue; const keyHit = /token|oauth|auth|session|login|xbase|user/i.test(k); const vHit = /access_token|accessToken/i.test(v.slice(0, 120)); if (!keyHit && !vHit) continue; try { const j = JSON.parse(v); const t = j.access_token || j.accessToken || (j.token && (j.token.access_token || j.token.accessToken)) || (j.data && (j.data.access_token || j.data.accessToken)); if (typeof t === "string" && t.length > 20) return t.trim(); } catch { /* 非 JSON */ } if (keyHit && /^[a-zA-Z0-9._-]{30,}$/.test(v.trim()) && !v.includes("{")) { return v.trim(); } } } catch { /* ignore */ } } return ""; }, async getAccessToken() { // 优先用拦截器捕获的 token（参考迅雷原理） if (panGuangya._capturedToken) return panGuangya._capturedToken; let t = String(GM_getValue(KEY_GUANGYA_ACCESS_TOKEN, "") || "").trim(); if (t) return t; t = panGuangya.pickTokenFromPageStorage(); if (t) return t; return await panGuangya.promptPasteToken(); }, /** 记录当前登录信息和目录，供迅雷提取后秒传使用 */ async recordStatus() { try { const token = await panGuangya.getAccessToken(); if (!token) { alert("未能获取登录信息（access_token），请确保已登录光鸭云盘。"); return; } // 🔑 关键修复：优先使用 URL 解析（始终反映当前页面状态） let folderId = panGuangya.getCurrentFolderId() || ""; // URL 无法解析时（如根目录且无路径），回退到拦截器缓存 if (!folderId && panGuangya._cachedListUrlTemplate) { folderId = panGuangya._extractParentIdFromCapturedRequest() || ""; } // 最后兜底：从缓存列表的 parentId 字段反推 if (!folderId && panGuangya._cachedCurrentList.length > 0) { const first = panGuangya._cachedCurrentList[0]; folderId = String(first?.parentId || first?.parent_id || first?.dirId || first?.dir_id || ""); } // 🔑 目录名也优先从 URL 解析，而非面包屑 DOM（可能未更新） let folderName = panGuangya.getCurrentFolderName() || "根目录"; // URL 解析失败时，从面包屑 DOM 获取 if (!folderName || folderName === "根目录") { try { const breadcrumb = document.querySelector("[class*='breadcrumb' i] [class*='active' i], [class*='breadcrumb' i] li:last-child, [class*='crumb' i] [class*='active' i]"); if (breadcrumb) folderName = breadcrumb.textContent.trim() || folderName; } catch { /* ignore */ } } GM_setValue(KEY_GUANGYA_RECORDED_TOKEN, token); GM_setValue(KEY_GUANGYA_RECORDED_FOLDER_ID, folderId); GM_setValue(KEY_GUANGYA_RECORDED_FOLDER_NAME, folderName); // 调试日志：显示目录ID来源 const urlHash = location.hash; console.log(`[光鸭记录] URL解析目录ID="${folderId || "(空)"}" 目录名="${folderName}" URL="${urlHash}"`); alert(`已记录状态！\n\n目录ID：${folderId || "(根目录)"}\n目录名：${folderName}\n\n现在可以到迅雷云盘提取JSON后点击「保存」秒传到此目录。`); } catch (e) { alert("记录状态失败：" + (e?.message || e)); } }, /** 从拦截器捕获的请求中提取 parentId */ _extractParentIdFromCapturedRequest() { try { const url = panGuangya._cachedListUrlTemplate || ""; // 从 URL query 中提取 const urlMatch = url.match(/[?&](?:parentId|parent_id|dirId|dir_id|fid|folderId|folder_id)=([^&]+)/i); if (urlMatch) { let id = decodeURIComponent(urlMatch[1]); id = id.replace(/[-_]+$/, ""); // 清理末尾的 - 或 _ return id; } // 从 POST body 模板中提取 const body = panGuangya._cachedListBodyTemplate; if (body && typeof body === "object") { for (const k of ["parentId", "parent_id", "dirId", "dir_id", "fid", "folderId", "folder_id", "id"]) { if (k in body && body[k] != null) { let id = String(body[k]); id = id.replace(/[-_]+$/, ""); return id; } } } return ""; } catch { return ""; } }, /** 读取已记录的状态 */ getRecordedStatus() { const token = String(GM_getValue(KEY_GUANGYA_RECORDED_TOKEN, "") || "").trim(); const folderId = String(GM_getValue(KEY_GUANGYA_RECORDED_FOLDER_ID, "") || "").trim(); const folderName = String(GM_getValue(KEY_GUANGYA_RECORDED_FOLDER_NAME, "") || "").trim(); return { token, folderId, folderName, hasRecord: !!token }; }, /** * 将 JSON 秒传到已记录的光鸭云盘目录（带进度条 + 持久化续跑） * @param {object} jsonData - 完整的 JSON 数据对象 * @param {object} [opts] * @param {boolean} [opts.isResume=false] - 是否续跑模式（来自上次中断） */ async saveToRecorded(jsonData, opts = {}) { const isResume = !!opts.isResume; const rec = panGuangya.getRecordedStatus(); if (!rec.hasRecord) { throw new Error("未记录光鸭云盘状态。请先到光鸭云盘页面点击「记录状态」按钮。"); } const files = jsonData?.files || []; if (!files.length) { throw new Error("JSON 中没有文件数据。"); } // 清理目录ID（去除末尾的 -_ 等字符） let targetDir = String(rec.folderId || "").replace(/[-_]+$/, ""); const displayName = rec.folderName || targetDir || "根目录"; // -------------------- 读取上次进度 / 成功集合（续跑场景） -------------------- let savedSuccessArr = []; if (isResume) { try { const raw = GM_getValue(KEY_GUANGYA_SAVE_SUCCESS_SET, "[]"); savedSuccessArr = Array.isArray(raw) ? raw : JSON.parse(String(raw)); } catch { savedSuccessArr = []; } } const successSet = new Set(savedSuccessArr); // 进度对象（跨标签页持久化） const saveProgress = { phase: "prepare", // prepare | mkdir | probe | done | error mkdirIndex: 0, mkdirTotal: files.length, probeIndex: 0, probeTotal: files.length, totalFiles: files.length, targetDirName: displayName, targetDirId: targetDir, isResume, updatedAt: Date.now(), errorMsg: "", }; const persistProgress = () => { saveProgress.updatedAt = Date.now(); try { GM_setValue(KEY_GUANGYA_SAVE_PROGRESS, JSON.stringify(saveProgress)); } catch { /* ignore */ } }; const persistSuccessSet = () => { try { GM_setValue(KEY_GUANGYA_SAVE_SUCCESS_SET, Array.from(successSet)); } catch { /* ignore */ } }; const clearPersistence = () => { try { GM_setValue(KEY_GUANGYA_SAVE_PROGRESS, ""); } catch { /* ignore */ } try { GM_setValue(KEY_GUANGYA_SAVE_SUCCESS_SET, "[]"); } catch { /* ignore */ } }; // -------------------- 进度回调：更新 UI + 持久化 -------------------- const onBatchProgress = (p) => { const phase = p.phase; // "mkdir" | "probe" const idx = Number(p.index) || 0; const total = Math.max(1, Number(p.total) || 1); if (phase === "mkdir") { saveProgress.phase = "mkdir"; saveProgress.mkdirIndex = idx; saveProgress.mkdirTotal = total; helper.updateLoadingProgress(idx, total, `创建目录 ${idx}/${total}`); } else if (phase === "probe") { saveProgress.phase = "probe"; saveProgress.probeIndex = idx; saveProgress.probeTotal = total; helper.updateLoadingProgress(idx, total, `秒传中 ${idx}/${total}`); } persistProgress(); }; // -------------------- 单条成功回调：加入成功集合 + 持久化 -------------------- const onItemSuccess = (key) => { successSet.add(key); // 每成功 5 条或间隔一下持久化，减少写频次 if (successSet.size % 5 === 0) persistSuccessSet(); }; // -------------------- 尝试多个可能的 parentId 值 -------------------- const candidates = []; if (targetDir) candidates.push({ id: targetDir, name: displayName }); candidates.push({ id: "", name: "空字符串(根目录)" }); candidates.push({ id: "0", name: "0(根目录)" }); candidates.push({ id: "root", name: "root(根目录)" }); candidates.push({ id: "1", name: "1(根目录)" }); for (const candidate of candidates) { // 首次尝试/切到新目录：重置进度状态 saveProgress.phase = "mkdir"; saveProgress.targetDirName = candidate.name; saveProgress.targetDirId = candidate.id || ""; saveProgress.errorMsg = ""; saveProgress.mkdirIndex = 0; saveProgress.probeIndex = 0; saveProgress.probeTotal = files.length; persistProgress(); const resumeHint = isResume && successSet.size > 0 ? `（续跑模式：已跳过 ${successSet.size} 条已成功文件）` : ""; helper.showLoadingDialog( "正在秒传到光鸭云盘", `目标目录：${candidate.name}\n目录ID：${candidate.id || "(空)"}\n共 ${files.length} 个文件 ${resumeHint}`, true, // 开启进度条 ); try { const result = await panGuangya.importMd5Json( jsonData, onBatchProgress, candidate.id, rec.token, { skipSet: successSet, onItemSuccess }, ); helper.closeLoadingDialog(); // 完成：标记进度 done 并清理持久化 saveProgress.phase = "done"; persistProgress(); persistSuccessSet(); // 最后兜底写一次 clearPersistence(); const s = result?.importSummary || {}; const resumeLine = isResume ? `\n续跑跳过已成功：${savedSuccessArr.length} 条` : ""; alert(`秒传完成！\n\n目标目录：${candidate.name}\n秒传成功：${s.instantHitCount || 0} 条\n传输成功：${s.transferSuccess || 0} 条\n传输失败：${s.transferFail || 0} 条\n跳过：${result?.skipCount || 0} 条${resumeLine}`); return; } catch (e) { helper.closeLoadingDialog(); persistSuccessSet(); // 出错前保存已成功的集合 const errMsg = String(e?.message || e); saveProgress.phase = "error"; saveProgress.errorMsg = errMsg; persistProgress(); // 如果是目录不存在，尝试下一个候选值 if (!errMsg.includes("目录不存在") && !errMsg.includes("not exist") && !errMsg.includes("parentId")) { // 非目录错误，保留进度（便于续跑），直接抛出 throw e; } // 继续尝试下一个候选目录：清除已成功集合（因为换了目录，已成功的是旧目录的，不算） successSet.clear(); persistSuccessSet(); } } // 所有候选都失败 clearPersistence(); throw new Error(`所有目录ID尝试均失败：${candidates.map(c => c.id || "空").join(", ")}\n请到光鸭云盘重新进入目标目录后点击「记录状态」。`); }, promptPasteToken() { return new Promise((resolve) => { const backdrop = document.createElement("div"); Object.assign(backdrop.style, { position: "fixed", inset: "0", background: "rgba(0,0,0,0.45)", zIndex: "2147483646", display: "flex", alignItems: "center", justifyContent: "center", fontFamily: "system-ui,sans-serif", }); const box = document.createElement("div"); box.style.cssText = "background:#fff;padding:18px 20px;border-radius:10px;max-width:92vw;width:440px;box-shadow:0 8px 32px rgba(0,0,0,.2)"; const p = document.createElement("p"); p.style.cssText = "margin:0 0 10px;font-size:13px;line-height:1.55;color:#333;"; p.innerHTML = "未在页面存储中找到 access_token。
请在已登录状态下打开开发者工具 → Network，点选任意发往 api.guangyapan.com 的请求，在请求头里复制 Authorization 的 Bearer 后面整段 token；或从 Application → Local Storage 里找 JSON 中的 access_token。"; const inp = document.createElement("input"); inp.type = "password"; inp.placeholder = "粘贴 access_token（可含 Bearer 前缀）"; inp.style.cssText = "width:100%;box-sizing:border-box;padding:8px 10px;border:1px solid #ccc;border-radius:6px;font-size:13px;margin-bottom:12px;"; const row = document.createElement("div"); row.style.cssText = "display:flex;gap:10px;justify-content:flex-end;"; const btnOk = document.createElement("button"); btnOk.textContent = "确定并保存"; btnOk.style.cssText = "padding:8px 16px;border-radius:6px;border:none;background:#1677ff;color:#fff;cursor:pointer;"; const btnCancel = document.createElement("button"); btnCancel.textContent = "取消"; btnCancel.style.cssText = "padding:8px 16px;border-radius:6px;border:1px solid #ccc;background:#fff;cursor:pointer;"; const cleanup = () => backdrop.remove(); btnCancel.onclick = () => { cleanup(); resolve(""); }; btnOk.onclick = () => { let v = inp.value.trim(); if (v.startsWith("Bearer ")) v = v.slice(7).trim(); if (v) GM_setValue(KEY_GUANGYA_ACCESS_TOKEN, v); cleanup(); resolve(v); }; row.appendChild(btnCancel); row.appendChild(btnOk); box.appendChild(p); box.appendChild(inp); box.appendChild(row); backdrop.appendChild(box); document.body.appendChild(backdrop); inp.focus(); }); }, // -------------------------------------------------------- // 导入秒传 JSON // -------------------------------------------------------- showImportDialog() { const backdrop = document.createElement("div"); Object.assign(backdrop.style, { position: "fixed", inset: "0", background: "rgba(0,0,0,0.45)", zIndex: "2147483646", display: "flex", alignItems: "center", justifyContent: "center", fontFamily: "system-ui,-apple-system,\"Microsoft YaHei\",sans-serif", }); const box = document.createElement("div"); box.style.cssText = "background:#fff;padding:20px 22px;border-radius:12px;width:92vw;max-width:680px;max-height:88vh;overflow:auto;box-shadow:0 12px 40px rgba(0,0,0,.25);"; const title = document.createElement("div"); title.innerHTML = "📥 导入JSON"; title.style.cssText = "font-size:17px;font-weight:700;margin-bottom:14px;color:#111;"; const fileRow = document.createElement("div"); fileRow.style.cssText = "margin-bottom:12px;display:flex;align-items:center;gap:10px;flex-wrap:wrap;"; const fileInput = document.createElement("input"); fileInput.type = "file"; fileInput.accept = ".json,application/json,text/json"; fileInput.style.cssText = "display:none;"; const fileBtnLabel = document.createElement("label"); fileBtnLabel.textContent = "选择文件"; fileBtnLabel.style.cssText = "padding:8px 16px;border-radius:8px;border:1px solid #ff9800;background:#fff8f0;color:#ff9800;cursor:pointer;font-size:13px;font-weight:600;flex-shrink:0;transition:all .2s;"; fileBtnLabel.onmouseenter = () => { fileBtnLabel.style.background = "#ff9800"; fileBtnLabel.style.color = "#fff"; }; fileBtnLabel.onmouseleave = () => { fileBtnLabel.style.background = "#fff8f0"; fileBtnLabel.style.color = "#ff9800"; }; fileBtnLabel.appendChild(fileInput); const btnClearFile = document.createElement("button"); btnClearFile.type = "button"; btnClearFile.textContent = "清除"; btnClearFile.title = "清空已选文件与下方 JSON，可重新选择"; btnClearFile.style.cssText = "padding:6px 12px;border-radius:6px;border:1px solid #ddd;background:#fafafa;color:#333;cursor:pointer;font-size:12px;flex-shrink:0;"; const fileLoadedHint = document.createElement("span"); fileLoadedHint.style.cssText = "font-size:11px;color:#888;word-break:break-all;flex:1;min-width:120px;"; const readFileAsTextPromise = (file) => new Promise((resolve, reject) => { const r = new FileReader(); r.onload = () => resolve(String(r.result || "")); r.onerror = () => reject(new Error("读取失败")); try { r.readAsText(file, "UTF-8"); } catch (e) { reject(e); } }); const status = document.createElement("div"); status.style.cssText = "margin-top:10px;font-size:12px;color:#c00;min-height:18px;white-space:pre-wrap;"; const detailWrap = document.createElement("div"); detailWrap.style.cssText = "display:none;margin-top:12px;"; const detailLabel = document.createElement("div"); detailLabel.textContent = "分类明细（接口失败 / 秒传失败 / 校验）"; detailLabel.style.cssText = "font-size:12px;color:#666;margin-bottom:8px;"; const detailTa = document.createElement("textarea"); detailTa.readOnly = true; detailTa.rows = 10; detailTa.style.cssText = "width:100%;box-sizing:border-box;font-size:11px;line-height:1.4;font-family:ui-monospace,monospace;padding:10px;border:1px solid #eee;border-radius:8px;resize:vertical;min-height:120px;background:#f8f9fa;"; const copyRow = document.createElement("div"); copyRow.style.cssText = "margin-top:8px;display:flex;gap:8px;align-items:center;flex-wrap:wrap;"; const btnCopyDetail = document.createElement("button"); btnCopyDetail.type = "button"; btnCopyDetail.textContent = "复制详情"; btnCopyDetail.style.cssText = "padding:6px 14px;border-radius:6px;border:1px solid #1677ff;background:#e6f4ff;color:#1677ff;cursor:pointer;font-size:12px;"; const copyHint = document.createElement("span"); copyHint.style.cssText = "font-size:11px;color:#999;"; copyRow.appendChild(btnCopyDetail); copyRow.appendChild(copyHint); const setDetailText = (text) => { if (text) { detailTa.value = text; detailWrap.style.display = "block"; } else { detailTa.value = ""; detailWrap.style.display = "none"; } }; btnCopyDetail.onclick = () => { const t = detailTa.value; if (!t) return; try { if (typeof GM_setClipboard === "function") { GM_setClipboard(t, "text"); copyHint.textContent = "已复制"; setTimeout(() => { copyHint.textContent = ""; }, 2000); return; } } catch { /* fallthrough */ } detailTa.focus(); detailTa.select(); try { document.execCommand("copy"); copyHint.textContent = "已复制"; setTimeout(() => { copyHint.textContent = ""; }, 2000); } catch { copyHint.textContent = "请手动 Ctrl+C"; } }; fileInput.addEventListener("change", async () => { const picked = fileInput.files; fileLoadedHint.textContent = ""; if (!picked || picked.length === 0) return; const f = picked[0]; try { const text = await readFileAsTextPromise(f); const vr = validateGuangyaImportJsonShape(text); if (!vr.ok) { fileInput.value = ""; ta.value = ""; fileLoadedHint.textContent = ""; status.style.color = "#c00"; status.textContent = `格式不符：${vr.message}`; return; } ta.value = text; fileLoadedHint.textContent = `格式校验通过 · ${f.name}（${(f.size / 1024).toFixed(1)} KB），共 ${vr.fileCount} 条`; status.textContent = ""; status.style.removeProperty("color"); setDetailText(""); } catch { fileLoadedHint.textContent = ""; status.style.color = "#c00"; status.textContent = "读取文件失败，请重试或改用粘贴"; } }); fileRow.appendChild(fileBtnLabel); fileRow.appendChild(btnClearFile); fileRow.appendChild(fileLoadedHint); const dirRow = document.createElement("div"); dirRow.style.cssText = "margin-bottom:12px;display:flex;align-items:center;gap:8px;flex-wrap:wrap;"; const dirLabel = document.createElement("span"); dirLabel.textContent = "选择目录："; dirLabel.style.cssText = "font-size:12px;color:#666;flex-shrink:0;"; const dirInput = document.createElement("input"); dirInput.type = "text"; dirInput.placeholder = "留空则使用当前页面目录"; dirInput.style.cssText = "flex:1;min-width:140px;max-width:220px;padding:8px 10px;border:1px solid #ddd;border-radius:8px;font-size:12px;box-sizing:border-box;"; const btnUseCurrent = document.createElement("button"); btnUseCurrent.type = "button"; btnUseCurrent.textContent = "当前目录"; btnUseCurrent.title = "将当前页面所在目录 ID 填入左侧"; btnUseCurrent.style.cssText = "padding:6px 12px;border-radius:6px;border:1px solid #1677ff;background:#e6f4ff;color:#1677ff;cursor:pointer;font-size:12px;flex-shrink:0;"; const dirHint = document.createElement("span"); dirHint.style.cssText = "font-size:11px;color:#888;flex:1;min-width:80px;word-break:break-all;"; const curFolderId = panGuangya.getCurrentFolderId(); // 初始化 dirHint：区分根目录和实际目录，文案更明确 if (curFolderId) { dirHint.textContent = `检测到当前目录 ID：${curFolderId}（点击右侧「当前目录」可填入）`; } else { dirHint.textContent = "检测到当前处于根目录（空值即代表根目录，无需填写）"; } btnUseCurrent.onclick = () => { const fid = panGuangya.getCurrentFolderId(); dirInput.value = fid || ""; if (fid) { dirHint.textContent = `已选择：目录 ID = ${fid}`; } else { dirHint.textContent = "已选择：根目录（空值代表根目录，文件将导入到最顶层）"; } }; dirRow.appendChild(dirLabel); dirRow.appendChild(dirInput); dirRow.appendChild(btnUseCurrent); dirRow.appendChild(dirHint); const ta = document.createElement("textarea"); ta.placeholder = '{"files":[{"path":"a.mp4","etag":"32位md5","gcid":"迅雷GCID","size":123}]}'; ta.style.cssText = "width:100%;box-sizing:border-box;min-height:160px;padding:12px;border:1px solid #ddd;border-radius:8px;font-size:12px;font-family:ui-monospace,monospace;margin-top:4px;background:#f8f9fa;"; detailWrap.appendChild(detailLabel); detailWrap.appendChild(detailTa); detailWrap.appendChild(copyRow); btnClearFile.onclick = () => { fileInput.value = ""; fileLoadedHint.textContent = ""; ta.value = ""; status.textContent = ""; status.style.removeProperty("color"); setDetailText(""); }; const row = document.createElement("div"); row.style.cssText = "display:flex;gap:10px;justify-content:flex-end;margin-top:16px;flex-wrap:wrap;"; const btnRun = document.createElement("button"); btnRun.textContent = "导入"; btnRun.style.cssText = "padding:10px 18px;border-radius:8px;border:none;background:#ff9800;color:#fff;cursor:pointer;font-weight:600;font-size:14px;"; const btnClose = document.createElement("button"); btnClose.textContent = "关闭"; btnClose.style.cssText = "padding:10px 18px;border-radius:8px;border:1px solid #ddd;background:#fff;color:#333;cursor:pointer;font-size:14px;"; const cleanup = () => backdrop.remove(); btnClose.onclick = cleanup; btnRun.onclick = async () => { if (btnRun._prechecked) { btnRun._prechecked = false; _runImport(); return; } status.textContent = ""; status.style.removeProperty("color"); setDetailText(""); const preCheckText = ta.value; const preVr = validateGuangyaImportJsonShape(preCheckText); if (!preVr.ok) { status.style.color = "#c00"; status.textContent = `校验失败：${preVr.message}`; return; } let preCheckObj; try { preCheckObj = JSON.parse(preCheckText); } catch { status.style.color = "#c00"; status.textContent = "JSON 解析失败，请检查格式"; return; } const preList = Array.isArray(preCheckObj.files) ? preCheckObj.files : []; const preSkip = []; let preValid = 0; for (const f of preList) { const pathStr = String(f.path || f.name || "").trim() || "file"; const gcidRaw = String(f.gcid || "").trim().toUpperCase(); if (gcidRaw) { if (gcidRaw.length !== 40) preSkip.push(`${pathStr}：gcid 长度 ${gcidRaw.length} 位，应为 40 位`); else preValid++; continue; } const ex = guangyaExtractMd5FromEtag(f.etag || f.md5); if (!ex.ok) preSkip.push(`${pathStr}：${ex.reason}`); else preValid++; } if (preSkip.length > 0) { if (preValid === 0) { status.style.color = "#c00"; status.textContent = `全部 ${preSkip.length} 条校验不通过，无法导入`; setDetailText(preSkip.join("\n")); return; } status.style.color = "#a60"; status.textContent = `预检：${preValid} 条可导入，${preSkip.length} 条校验不通过将跳过（详见下方明细）。确认无误请再次点击导入`; setDetailText(preSkip.join("\n")); btnRun.textContent = "确认导入"; btnRun.style.background = "#1677ff"; btnRun._prechecked = true; return; } _runImport(); }; ta.addEventListener("input", () => { if (btnRun._prechecked) { btnRun._prechecked = false; btnRun.textContent = "导入"; btnRun.style.background = "#ff9800"; status.textContent = ""; status.style.removeProperty("color"); setDetailText(""); } }); const _runImport = async () => { btnRun.textContent = "导入中"; btnRun.disabled = true; btnRun.style.cursor = "not-allowed"; btnRun.style.opacity = "0.75"; btnRun.style.background = "#ff9800"; status.style.color = "#1677ff"; status.textContent = "导入中..."; try { const targetDirId = String(dirInput.value || "").trim(); const r = await panGuangya.importMd5Json(ta.value, (p) => { status.style.color = "#1677ff"; if (p.phase === "mkdir") status.textContent = `导入中... 创建目录 ${p.index}/${p.total}`; else if (p.phase === "probe") status.textContent = `导入中... 秒传 ${p.index}/${p.total}`; else status.textContent = `导入中... 第 ${p.index}/${p.total} 批（本批 ${p.chunkSize} 条）`; }, targetDirId || undefined); const sum = r.importSummary; const mkdirFailedCount = Number(sum.mkdirFailedCount) || 0; const transferTotal = sum.transferSuccess + sum.transferFail + mkdirFailedCount; const transferFailTotal = sum.transferFail + mkdirFailedCount; const nonMkdirSkipCount = Math.max(0, (sum.skipCount || 0) - mkdirFailedCount); const probeCount = sum.probeTotal != null ? Number(sum.probeTotal) || 0 : sum.transferSuccess + sum.transferFail; const lines = [ `阶段统计：创建目录失败（未进入秒传）${mkdirFailedCount} 条；进入秒传阶段 ${probeCount} 条。`, `秒传结果：共 ${transferTotal} 条，成功 ${sum.transferSuccess} 条，失败 ${transferFailTotal} 条，其中 ${mkdirFailedCount} 条因创建目录失败未导入。`, ]; if (nonMkdirSkipCount > 0) lines.push(`校验未通过（未提交接口）：${nonMkdirSkipCount} 条。`); const warn = transferFailTotal > 0 || nonMkdirSkipCount > 0; status.style.color = warn ? "#a60" : "#080"; status.textContent = lines.join("\n"); const xferRows = sum.transferFailedEntries || []; const needCopy = sum.transferFail > 0 || sum.skipCount > 0 || sum.transferFailedMissingDetail; if (needCopy) { const transferExtra = []; const rawSkipped = Array.isArray(r.skipped) ? r.skipped : []; const mkdirSkipLines = rawSkipped.filter(x => String(x).includes("创建目录失败")); const validateSkipLines = rawSkipped.filter(x => !String(x).includes("创建目录失败")); // 根据实际状态生成接口调用说明，不再无条件写死"均成功" let interfaceLines; if (probeCount === 0) { interfaceLines = [ `未发起秒传接口：条目不合法或创建目录阶段全部失败，${probeCount} 条进入秒传阶段。`, `校验未通过 ${nonMkdirSkipCount} 条 + 创建目录失败 ${mkdirFailedCount} 条。`, ]; } else if (sum.transferFail === 0) { interfaceLines = [`进入秒传阶段 ${probeCount} 条，各批 HTTP 状态与业务 code 均成功。`]; } else { // 有失败：如果明细齐全则不列 HTTP，明细缺失则专门说明 if (sum.transferFailedMissingDetail) { interfaceLines = [`进入秒传阶段 ${probeCount} 条，各批 HTTP 状态与业务 code 虽返回成功，但实际未命中资源中心。`]; } else { interfaceLines = [`进入秒传阶段 ${probeCount} 条，${sum.transferSuccess} 条命中成功，${sum.transferFail} 条命中失败（明细见下方）。`]; } } if (sum.transferFailedMissingDetail && sum.transferFail > 0) { transferExtra.push(`（说明：共有 ${sum.transferFail} 条秒传失败，但接口未返回失败明细，无法逐条列出路径。）`); } setDetailText(formatGuangyaImportCopyReport({ interfaceLines: interfaceLines, transferRows: xferRows, mkdirSkipLines: mkdirSkipLines.length > 0 ? mkdirSkipLines : undefined, validateSkipLines: validateSkipLines.length > 0 ? validateSkipLines : undefined, transferExtraLines: transferExtra, })); } else { setDetailText(""); } } catch (e) { status.style.color = "#c00"; status.textContent = e?.message || String(e); const iface = [ e?.message || String(e), "", e?.importFailedAtProbeIndex != null ? `失败位置：第 ${e.importFailedAtProbeIndex} 条（秒传阶段）。` : "", ].filter(Boolean); if (e?.guangyaDetail) iface.push("", String(e.guangyaDetail)); const xferRows = Array.isArray(e?.partialTransferFailures) ? e.partialTransferFailures : []; setDetailText(formatGuangyaImportCopyReport({ interfaceLines: iface, transferRows: xferRows })); } finally { btnRun.textContent = "导入"; btnRun.style.background = "#ff9800"; btnRun.disabled = false; btnRun.style.cursor = "pointer"; btnRun.style.opacity = "1"; btnRun._prechecked = false; } }; row.appendChild(btnRun); row.appendChild(btnClose); box.appendChild(title); box.appendChild(fileRow); box.appendChild(dirRow); box.appendChild(ta); box.appendChild(status); box.appendChild(detailWrap); box.appendChild(row); backdrop.appendChild(box); backdrop.addEventListener("click", (e) => { if (e.target === backdrop) backdrop.remove(); }); document.body.appendChild(backdrop); ta.focus(); }, async importMd5Json(rawJson, onBatchProgress, overrideParentId, overrideToken, options = {}) { // options.skipSet: Set - 续跑时跳过的 md5/gcid 集合 // options.onItemSuccess: (key: string) => void - 单条成功回调 const { skipSet = null, onItemSuccess = null } = options; let obj; try { obj = typeof rawJson === "string" ? JSON.parse(rawJson) : rawJson; } catch { const err = new Error("JSON 解析失败"); err.guangyaDetail = guangyaJsonDetail({ summary: err.message, phase: "解析输入" }); throw err; } const list = Array.isArray(obj.files) ? obj.files : []; if (!list.length) { const err = new Error("JSON 中无 files 数组"); err.guangyaDetail = guangyaJsonDetail({ summary: err.message, phase: "校验", hint: "顶层需有 files 数组" }); throw err; } const token = overrideToken || await panGuangya.getAccessToken(); if (!token) { const err = new Error("未设置 access_token，已取消"); err.guangyaDetail = guangyaJsonDetail({ summary: err.message, phase: "登录态" }); throw err; } // 优先从拦截器捕获的真实请求中获取 parentId（与 recordStatus 逻辑一致） let _autoFolderId = ""; if (panGuangya._cachedListBodyTemplate) { _autoFolderId = panGuangya._extractParentIdFromCapturedRequest() || ""; } if (!_autoFolderId) _autoFolderId = panGuangya.getCurrentFolderId(); const rootParentId = (typeof overrideParentId === "string" && overrideParentId.trim()) ? overrideParentId.trim() : _autoFolderId; // 🛡️【根因修复】从【顶层JSON】和【行级】读取 shareId/passCodeToken： // 迅雷分享页提取的 JSON 通常把 shareId 写在顶层 obj.shareId / obj.passCodeToken， // 部分旧版本会逐行写 row.shareId / row.passCodeToken。 // 若不把这些值透传给后面的 getFileDetail，则分享页路径1/2/3完全不跑， // 只剩路径4 drive/v1/files/{id}（需要登录态），大都是匿名无权限返回空 → 永远拿不到 downloadUrl， // → 永远算不出 cid → check_can_flash_upload 只能发 gcid+md5-only 空 combo → 必败。 const jsonTopShareId = String((obj && obj.shareId) || "").trim(); const jsonTopPassCodeToken = String((obj && obj.passCodeToken) || "").trim(); const jsonTopSourceTag = String((obj && obj.sourceTag) || (obj && obj.source) || "").trim().toLowerCase(); const files = []; const skip = []; for (const f of list) { const pathStr = String(f.path || "").trim(); const nameStr = String(f.name || "").trim(); const fullPath = pathStr || nameStr || "file"; const numSize = Number(f.size != null ? f.size : 0); const gcidRaw = String(f.gcid || "").trim().toUpperCase(); // 行级 shareId / passCodeToken 优先级 > 顶层 JSON 全局 shareId / passCodeToken const rowShareId = String(f.shareId || "").trim() || jsonTopShareId; const rowPassCodeToken = String(f.passCodeToken || "").trim() || jsonTopPassCodeToken; if (gcidRaw) { if (gcidRaw.length !== 40) { skip.push(`${fullPath}：gcid 长度 ${gcidRaw.length} 位，应为 40 位`); continue; } files.push({ gcid: gcidRaw, filePath: fullPath, fileName: guangyaBasenameFromPath(fullPath), dirSegments: guangyaDirSegmentsFromPath(fullPath), fileSize: Number.isFinite(numSize) && numSize >= 0 ? numSize : 0, cid: String(f.cid || "").trim(), // 光鸭秒传接口要求的采样哈希；若为迅雷源，这里就是我们 enrich 阶段用 Range 样本算出来的真实 tripleCid fileId: String(f.fileId || "").trim(), // 光鸭文件ID，用于自动计算cid parentId: String(f.parentId || "").trim(), // 光鸭父目录ID md5: String(f.md5 || "").trim(), // 迅雷md5_checksum 或 gcid前32位兜底；没有也传空（后续 combo 生成里会兜底） downloadUrl: String(f.downloadUrl || "").trim(), // 迅雷源的 web_content_link / links.octet-stream.url；用于 OSS 流式实际上传兜底和 cid 计算 shareId: rowShareId, // 【关键】透传：给 getFileDetail 分享页路径1/2/3 必须要 passCodeToken: rowPassCodeToken, sourceTag: jsonTopSourceTag || (String(f.sourceTag || f.source || "").trim().toLowerCase()), }); continue; } const ex = guangyaExtractMd5FromEtag(f.etag || f.md5); if (!ex.ok) { skip.push(`${fullPath}：${ex.reason}`); continue; } files.push({ md5: ex.md5, filePath: fullPath, fileName: guangyaBasenameFromPath(fullPath), dirSegments: guangyaDirSegmentsFromPath(fullPath), fileSize: Number.isFinite(numSize) && numSize >= 0 ? numSize : 0, fileId: String(f.fileId || "").trim(), // 光鸭文件ID，用于自动计算cid parentId: String(f.parentId || "").trim(), // 光鸭父目录ID cid: String(f.cid || "").trim(), // 若 MD5 源 JSON 碰巧带了 cid（迅雷导出的双字段源），也带上 gcid: String(f.gcid || "").trim().toUpperCase(), // 若 MD5 源又带 gcid（少见，但别丢），带上用于 check combo 兜底 downloadUrl: String(f.downloadUrl || "").trim(), // 同上，下载链接给实际上传兜底路径 shareId: rowShareId, // 【关键】透传 passCodeToken: rowPassCodeToken, sourceTag: jsonTopSourceTag || (String(f.sourceTag || f.source || "").trim().toLowerCase()), }); } if (!files.length) { const preview = skip.slice(0, 5).join("\n"); const msg = `没有可用的有效 MD5 或 gcid，常见原因：etag 虽 32 位但含字母 p/n 等非十六进制字符（不是标准 MD5）。\n${preview}${skip.length > 5 ? "\n…" : ""}`; const err = new Error(msg); err.guangyaDetail = guangyaJsonDetail({ summary: "无有效 MD5 条目", phase: "校验", skipped: skip, parentId: rootParentId }); throw err; } const dirIdCache = new Map(); dirIdCache.set("", rootParentId); let mkdirFailedCount = 0; const ensureDirPath = async (row) => { const parts = Array.isArray(row.dirSegments) ? row.dirSegments : []; if (!parts.length) return rootParentId; let currentParentId = rootParentId; let fullDirPath = ""; for (const dirNameRaw of parts) { const dirName = String(dirNameRaw || "").trim(); if (!dirName) continue; fullDirPath = fullDirPath ? `${fullDirPath}/${dirName}` : dirName; if (dirIdCache.has(fullDirPath)) { currentParentId = String(dirIdCache.get(fullDirPath) || ""); continue; } const parentIdForReq = String(currentParentId || ""); let mkdirBody; try { const ret = await helper.postJsonGuangya( GUANGYA_URL_CREATE_DIR, { dirName, parentId: parentIdForReq, failIfNameExist: true }, token, { allowedBusinessCodes: [0, GUANGYA_CODE_DIR_EXISTS] }, ); mkdirBody = ret.data; } catch (mkdirErr) { mkdirFailedCount += 1; let codeText = ""; try { const d = JSON.parse(String(mkdirErr?.guangyaDetail || "{}")); if (d && d.responseBody && d.responseBody.code != null) codeText = String(d.responseBody.code); } catch { /* ignore */ } skip.push(`${row.filePath}：创建目录失败（目录=${fullDirPath}${codeText ? `，code=${codeText}` : ""}），已跳过`); return null; } const nextId = guangyaPickFileIdFromObj(mkdirBody && mkdirBody.data); if (!nextId) { mkdirFailedCount += 1; skip.push(`${row.filePath}：创建目录失败（目录=${fullDirPath}，无法取得目录ID），已跳过`); return null; } dirIdCache.set(fullDirPath, nextId); currentParentId = nextId; } return String(currentParentId || ""); }; const payloadFiles = []; for (let i = 0; i < files.length; i++) { const row = files[i]; if (typeof onBatchProgress === "function") { try { onBatchProgress({ phase: "mkdir", index: i + 1, total: files.length, chunkSize: 1 }); } catch { /* ignore */ } } const parentId = await ensureDirPath(row); if (parentId == null) continue; payloadFiles.push({ md5: row.md5, gcid: row.gcid, filePath: row.filePath, fileName: row.fileName, fileSize: row.fileSize, parentId, fileId: row.fileId || "", // 传递fileId用于自动计算cid cid: row.cid || "", // 传递cid（迅雷源 JSON 里的真实 tripleCid，避免 payload 丢失导致 check_can_flash_upload 用假 cid 兜底） downloadUrl: row.downloadUrl || "", // 传递下载链接：用于 cid 再计算或 OSS 流式实际上传兜底 shareId: row.shareId || "", // 【关键】透传到处理循环：供 getFileDetail 跑分享页路径1/2/3 passCodeToken: row.passCodeToken || "", sourceTag: row.sourceTag || "", }); } let lastResp = null; let aggTransferOk = 0; let aggTransferFail = 0; const transferFailedEntries = []; const probeTotal = payloadFiles.length; let instantHitCount = 0; const pushFailRow = (row) => { aggTransferFail += 1; transferFailedEntries.push({ md5: row.md5 || row.gcid || "", filePath: row.filePath }); }; // 🔥 并发秒传：5 路并发处理，大幅缩短多文件总耗时 const CONCURRENCY = Math.min(5, payloadFiles.length); let _probeStarted = 0; let _firstError = null; const _processOneFile = async (fi) => { const row = payloadFiles[fi]; _probeStarted++; if (typeof onBatchProgress === "function") { try { onBatchProgress({ phase: "probe", index: _probeStarted, total: probeTotal, chunkSize: 1 }); } catch { /* ignore */ } } await helper.sleep(0); // 如果 md5/gcid 已在成功集合中（续跑场景），直接跳过算成功 const successKey = row.gcid ? ("G:" + row.gcid) : ("M:" + (row.md5 || "")); if (skipSet && skipSet.has(successKey)) { instantHitCount += 1; aggTransferOk += 1; return; } try { if (row.gcid) { // gcid 秒传路径（迅雷导出 / 光鸭自身提取） // 抓包分析 v6（2026-08-01）最终结论： // - 成功路径 A：get_res_center_token 返回 code=156（瞬时命中，无需后续步骤） // - 成功路径 B：check_can_flash_upload 返回 canFlashUpload:true，后轮询完成 // - check_can_flash_upload 要求必须传 {taskId, gcid, cid, fileSize}，缺任一返回 code=112 参数错误 // - cid = gcid 替代或全零虽然不报错，但也不会触发 canFlashUpload:true（cid不正确） // - 只有真实 cid + gcid + fileSize 三者同时匹配才能命中 // - 迅雷云盘提取的 f.cid 是真实值（3×20KB 采样SHA-1），有 cid 的 JSON 成功率最高 // - 光鸭 API（get_file_list）不返回 cid，因此对于光鸭→光鸭复制，只有 get_res_center_token 瞬时命中才有机会成功 const gcidStr = String(row.gcid || "").trim().toUpperCase(); let cidStr = String(row.cid || "").trim().toUpperCase(); const fileSizeNum = Number(row.fileSize) || 0; const ZERO_CID = "0".repeat(40); let lowerGcid = gcidStr.toLowerCase(); let lowerCid = cidStr.toLowerCase(); // 迅雷JSON一般自带 md5；缺失时兜底用 gcid 前32位 let md5Str = String(row.md5 || "").trim().toLowerCase(); if (!/^[0-9a-fA-F]{32}$/.test(md5Str) && /^[0-9a-fA-F]{40}$/.test(gcidStr)) { md5Str = lowerGcid.slice(0, 32); } const upperMd5 = md5Str ? md5Str.toUpperCase() : ""; // 🛡️ 提前声明 cid 变量：shouldComputeCid 条件（L3311-L3317）需要引用它们， // 避免 'Cannot read properties of undefined (reading slice)' —— JavaScript 变量无 TDZ，但 // 如果变量声明在另一个 try/catch 内部或被跳过，这里仍可能访问到未初始化值 let computedCidObj = null; let wholeCidLower = ""; // 整个文件单份SHA-1（小文件可能用这个） let wholeCidUpper = ""; let tripleCidLower = ""; // 3x20KB拼接SHA-1（标准迅雷cid） let tripleCidUpper = ""; let wholeFileBufferForUpload = null; // 整个文件内容（≤100MB时用于OSS上传兜底） // 🛡️ 提前声明行级 cid 候选变量（getCidFromFileId 调用在 L3415+ 需要引用，必须先声明避免 TDZ） let rowCidCandidate = ""; let rowWholeCidCandidate = ""; let rowTripleCidCandidate = ""; let hasAnyValidJsonCid = false; // 自动计算 cid：只要有 fileId（光鸭源）或 downloadUrl（迅雷源），就一定算一次拿到 wholeCid/tripleCid 双候选 // 之前的 !cidStr 条件太严：JSON 已有一个 cid（比如只有 wholeCid）时跳过计算，导致导入光鸭时后端索引命中的是另一个 cid（tripleCid）→ 直接漏掉 // 光鸭后端索引：有时 wholeCid 命中，有时 tripleCid 命中，必须两个都有才能保证 check_can_flash_upload 5 次内命中 const hasComputedCidSource = fileSizeNum > 0 && (row.fileId || row.downloadUrl); const shouldComputeCid = hasComputedCidSource && ( !cidStr || !/^[0-9a-fA-F]{40}$/.test(cidStr) // 即使已有 cidStr，仍强制算一次拿到双候选（成功率从 1/2 变 2/2）；但如果已有两个有效 cid 就跳过省流量 || !tripleCidLower || !wholeCidLower ); if (shouldComputeCid) { try { const WHOLE_FILE_MAX = 100 * 1024 * 1024; const SAMPLE = 20 * 1024; // 🛡️ 通用工具：判断 JSON 自带的 cid/wholeCid/tripleCid/md5 是否是合法的 40 hex（或 32 hex 做兜底） // 挪到 try 入口，保证后面任何分支都能引用（之前的 "ReferenceError: isValidCidFromJson is not defined" 就是作用域/名字写错导致） // 🔴 关键修复：cid==gcid（大小写不敏感）时返回 false —— gcid 不是真正的 SHA-1 cid， // 旧版提取脚本可能把 gcid 误填为 cid，导致代码误信"JSON已有cid"而跳过 helper 下载计算 const _gcidLower = String(row?.gcid || "").trim().toLowerCase(); const isValidCidFromJson = (s) => { if (typeof s !== "string") return false; const t = s.trim(); if (!/^[0-9a-fA-F]{40}$/.test(t)) return false; // cid 不能等于 gcid（gcid 不是文件内容的 SHA-1，是 Merkle root hash） if (_gcidLower && t.toLowerCase() === _gcidLower) { console.warn(`[光鸭秒传] ⚠️ cid 值与 gcid 相同（${t.slice(0,16)}…），判定为无效 cid（gcid 不是 SHA-1），将强制调 helper 下载计算`); return false; } return true; }; const isValidMd5FromJson = (s) => typeof s === "string" && /^[0-9a-fA-F]{32}$/.test(s); // 策略： // 1) 只要 JSON 里有 downloadUrl（迅雷源，分享页补全出来的 web_content_link）， // 永远优先内联用它 Range 样本计算 cid —— 这是个带签名的公开 URL。 // 2) 只有 downloadUrl 完全缺失时，才考虑 fileId。 // 为了避免把「迅雷分享页的 fileId」错传进光鸭 get_res_download_url， // 只有当 JSON 显式标记 sourceGuangya:true / isGuangyaFile:true 时才调用光鸭 helper； // 否则保守跳过 helper，避免误导性的控制台 warning。 let computedSourceUrl = ""; let needGuangyaHelper = false; const rowLooksLikeXunlei = !!(row && typeof row === "object" && (row.sourceXunlei || String(row.sourceTag || "").toLowerCase().includes("xunlei") || String(row.source || "").toLowerCase().includes("xunlei") || row.shareId || row.passCodeToken || row.xunleiShareId || row.kulvUrl || row.kulvKey)); // 清理 downloadUrl：去除首尾反引号、引号等包裹字符后再做正则检测 const cleanRowDlUrl = String(row.downloadUrl || "").trim().replace(/^[\s`"'']+|[\s`"'']+$/g, ""); // 🔴 关键修复：图片 CDN URL（88cdn / backstage-img / thumbnail 等）不能用于文件下载， // 视为无效 downloadUrl → 触发后续 getFileDetail 回退分支重新获取真实下载链接。 // 之前直接信任 cleanRowDlUrl，导致内联 Range 取样拿到 JPG/PNG 二进制，cid 算错秒传必失败。 const rowDlIsImageCdn = isImageCdnUrl(cleanRowDlUrl); if (rowDlIsImageCdn) { console.warn(`[光鸭秒传] ⚠️ JSON 自带 downloadUrl 是图片 CDN（${String(cleanRowDlUrl).slice(0, 80)}…），忽略此 URL → 尝试现场调 getFileDetail 补真实下载链接。fileId=${String(row.fileId || "").slice(0,24)}…`); } if (cleanRowDlUrl && /^https?:\/\//i.test(cleanRowDlUrl) && !rowDlIsImageCdn) { computedSourceUrl = cleanRowDlUrl; console.log(`[光鸭秒传] 用 JSON 自带 downloadUrl 计算 cid：${String(row.filePath || "").slice(0, 60)}`); } else if (rowLooksLikeXunlei && row.fileId && panXunlei && typeof panXunlei.getCidFromFileId === "function") { // 🚀🚀 【迅雷源最高优先级】先查 GM 持久化 xunlei_fileid_cid_cache_v1 // 前一次在 pan.xunlei.com 提取 JSON 时 enrich 算了 cid 就写入了， // 24h 内跨标签页/跨域名读得到 —— 完全跳过 helper 下载计算，成功率 100% const xCached = panXunlei.getCidFromFileId(row.fileId); if (xCached && typeof xCached === "object" && (xCached.tripleCid || xCached.wholeCid)) { if (xCached.tripleCid && !rowTripleCidCandidate) rowTripleCidCandidate = xCached.tripleCid; if (xCached.wholeCid && !rowWholeCidCandidate) rowWholeCidCandidate = xCached.wholeCid; if (xCached.md5 && /^[0-9a-fA-F]{32}$/.test(xCached.md5) && !md5Str) { md5Str = xCached.md5; if (md5Str) upperMd5 = md5Str.toUpperCase(); } if (xCached.downloadUrl && !computedSourceUrl) computedSourceUrl = xCached.downloadUrl; hasAnyValidJsonCid = !!(rowCidCandidate || rowWholeCidCandidate || rowTripleCidCandidate); } } if (rowLooksLikeXunlei && row.fileId && panXunlei && typeof panXunlei.getFileDetail === "function" && !computedSourceUrl) { // 迅雷源但没有 downloadUrl（比如 enrich 失败 / 链接过期 / 图片CDN误填 / 缓存没命中）： // 现场再调一次迅雷 getFileDetail 补下载链接 // 🛡️ 关键：无 shareId 场景 = 「自己网盘提取的 JSON」 → 必须切 useAnonymousAuth(false) 用登录 Bearer token 调路径4， // 否则 getAuthHeaders() 会用空串开 Bearer 导致 401 const xShareId = String(row.shareId || "").trim(); const xPass = String(row.passCodeToken || "").trim(); if (!xShareId && typeof panXunlei.useAnonymousAuth === "function") { try { panXunlei.useAnonymousAuth(false); } catch {} } // 🛡️ 从 GM 持久化读取一遍（导入端在 guangyapan.com 不在 pan.xunlei.com，_cachedToken 可能是 undefined） try { if (typeof panXunlei._getPersistentBearerToken === "function") try { panXunlei._getPersistentBearerToken(); } catch {} if (typeof panXunlei._getPersistentCaptchaToken === "function") try { panXunlei._getPersistentCaptchaToken(); } catch {} if (typeof panXunlei._getPersistentDeviceId === "function") try { panXunlei._getPersistentDeviceId(); } catch {} } catch {} try { console.log(`[光鸭秒传] 迅雷源行缺少有效 downloadUrl${rowDlIsImageCdn ? "（图片CDN误填）" : ""}，现场调 getFileDetail 补（fileId=${String(row.fileId).slice(0,24)}… shareId=${xShareId ? "有" : "无"}）`); const xDetail = await panXunlei.getFileDetail( row.fileId, xShareId, xPass, { parentId: row.parentId || "" } ); if (xDetail) { const tmpEntry = panXunlei._normalizeFileEntry(xDetail, row.filePath || "", row.parentId || ""); let tmpDl = (tmpEntry && tmpEntry.downloadUrl) ? tmpEntry.downloadUrl : ""; if (tmpDl && isImageCdnUrl(tmpDl)) tmpDl = ""; if (!tmpDl && panXunlei._extractDlFromDetailFlat) tmpDl = panXunlei._extractDlFromDetailFlat(xDetail); if (tmpDl && /^https?:\/\//i.test(tmpDl) && !isImageCdnUrl(tmpDl)) { computedSourceUrl = tmpDl; console.log(`[光鸭秒传] ✅ 迅雷现场补到 downloadUrl → 继续算 cid（链接前缀：${String(tmpDl).slice(0, 60)}…）`); } else { console.warn(`[光鸭秒传] 迅雷现场 getFileDetail 返回但仍无有效 downloadUrl（links/web_content_link 全空或仍是图片CDN，flat scan 也没命中）→ 跳过 cid 计算，仅用 gcid+md5 组合探秒传`); } } } catch (xErr) { console.warn(`[光鸭秒传] 迅雷现场补 downloadUrl 异常：${String(xErr?.message || xErr).slice(0, 200)}`); } } else if (row.fileId) { const isObj = row && typeof row === "object"; // ✅ 显式识别布尔标记（修复之前的 bug：String(true) = "true"，正则永远不匹配） // 同时兼容字符串 "true"（某些旧脚本/JSON 序列化可能产生字符串） const sgVal = isObj ? row.sourceGuangya : undefined; const guangyaBoolTrue = !!(sgVal === true || sgVal === "true" || row.isGuangyaFile === true || row.isGuangyaFile === "true"); const tagRaw = String(isObj ? (row.sourceGuangya ?? row.isGuangyaFile ?? row._from ?? "") : ""); const hasExplicitGuangyaTag = guangyaBoolTrue || /guangya|光鸭|guangya-origin/i.test(tagRaw); const fileIdLooksGuangya = typeof row.fileId === "string" && /^\d{15,25}$/.test(row.fileId); // 🔓 自动识别兜底：即使 sourceGuangya 标记丢失/检测失败， // 只要 fileId 格式符合光鸭（15-25 位纯数字）且无迅雷特征字段且 gcid 是合法 40 hex， // 就判定为光鸭源 —— 这覆盖了绝大多数正常场景（提取脚本正确、但 tag 被中间流程吞掉的情况） const gcidStr = (row && typeof row.gcid === "string") ? String(row.gcid).trim() : ""; const gcidLooksValid40 = /^[0-9a-fA-F]{40}$/.test(gcidStr); const autoDetectedGuangyaSource = !hasExplicitGuangyaTag && fileIdLooksGuangya && !rowLooksLikeXunlei && gcidLooksValid40; const isGuangyaSource = hasExplicitGuangyaTag || autoDetectedGuangyaSource; if (!hasExplicitGuangyaTag && autoDetectedGuangyaSource) { const _sgStr = (sgVal === undefined || sgVal === null) ? String(sgVal) : String(JSON.stringify(sgVal)); console.warn(`[光鸭秒传] 🔍 sourceGuangya 标记缺失/未识别，但根据 fileId 格式(15-25位)+无迅雷特征+gcid合法 → 自动判定为光鸭源（fileId=${String(row.fileId).slice(0,24)}…，sourceGuangya类型=${typeof sgVal}，值=${_sgStr.slice(0,30)}，gcid=${gcidStr.slice(0,16)}…）`); } // 🔒🔒 只要有任何迅雷特征字段（sourceXunlei/shareId/passCodeToken/...）就绝对不进光鸭 helper needGuangyaHelper = isGuangyaSource && fileIdLooksGuangya && !rowLooksLikeXunlei; // 🚀🚀 最高优先级：光鸭源 fileId → 本地响应缓存取 cid（100% 准确，是光鸭 API 自己返回的） // 在用户先浏览文件夹（API已加载），然后再导入 JSON 的流程里， // _cachedFileIdMap 一定能命中，能直接拿到 tripleCid/wholeCid/md5/gcid/downloadUrl if (isGuangyaSource && fileIdLooksGuangya && typeof panGuangya?.getCidFromFileId === "function") { const cachedCid = panGuangya.getCidFromFileId(row.fileId); if (cachedCid && typeof cachedCid === "object" && (cachedCid.tripleCid || cachedCid.wholeCid)) { const cachedTriple = isValidCidFromJson(cachedCid.tripleCid); const cachedWhole = isValidCidFromJson(cachedCid.wholeCid); if (cachedTriple || cachedWhole) { if (!computedCidObj) computedCidObj = {}; if (cachedTriple && !computedCidObj.tripleCid) computedCidObj.tripleCid = cachedTriple.toLowerCase(); if (cachedWhole && !computedCidObj.wholeCid) computedCidObj.wholeCid = cachedWhole.toLowerCase(); if (cachedCid.downloadUrl && !computedSourceUrl) computedSourceUrl = cachedCid.downloadUrl; if (cachedCid.md5 && /^[0-9a-fA-F]{32}$/.test(cachedCid.md5)) { if (!rowMd5Lower) rowMd5Lower = cachedCid.md5.toLowerCase(); } console.log(`[光鸭秒传] ✅✅ 本地 fileId 缓存命中（getCidFromFileId）：tripleCid=${cachedTriple ? "已取到" : "无"} wholeCid=${cachedWhole ? "已取到" : "无"} md5=${cachedCid.md5 ? "有" : "无"} dlUrl=${cachedCid.downloadUrl ? "有" : "无"} → 完全跳过 helper 下载计算，秒传命中率 100%`); // 让后面 hasAnyValidJsonCid 等逻辑也能识别到这两个 cid 已经有了 if (cachedTriple && !rowTripleCidCandidate) rowTripleCidCandidate = cachedTriple.toLowerCase(); if (cachedWhole && !rowWholeCidCandidate) rowWholeCidCandidate = cachedWhole.toLowerCase(); if (!rowCidCandidate && cachedTriple) rowCidCandidate = cachedTriple.toLowerCase(); hasAnyValidJsonCid = !!(rowCidCandidate || rowWholeCidCandidate || rowTripleCidCandidate); } } } // 🚀 用户明确要求：JSON 含有 sourceGuangya:true 就『直接用 cid』 // 先信任 JSON 自带的 cid/wholeCid/tripleCid（只要是合法 40 hex）， // 只有当这些全都空时才调 helper.downloadAndComputeCid 去现场计算 // 注意：变量已提前声明在 L3324-L3327，这里重新赋值 rowCidCandidate = isValidCidFromJson(row.cid); rowWholeCidCandidate = isValidCidFromJson(row.wholeCid); rowTripleCidCandidate = isValidCidFromJson(row.tripleCid); hasAnyValidJsonCid = rowCidCandidate || rowWholeCidCandidate || rowTripleCidCandidate; if (isGuangyaSource && hasAnyValidJsonCid && !computedCidObj) { computedCidObj = { tripleCid: (rowTripleCidCandidate ? String(row.tripleCid).toLowerCase() : (rowCidCandidate ? String(row.cid).toLowerCase() : "")), wholeCid: (rowWholeCidCandidate ? String(row.wholeCid).toLowerCase() : (rowCidCandidate ? String(row.cid).toLowerCase() : "")), }; console.log(`[光鸭秒传] ✅ 检测到 sourceGuangya=true，直接信任 JSON 自带 cid（cid=${computedCidObj.tripleCid ? "triple已取到" : "无"} whole=${computedCidObj.wholeCid ? "whole取到" : "无"}，跳过 helper 下载计算`); // 即使直接用了 JSON cid，后面还要继续走完后面 cid 计算流程（把 tripleCidLower/wholeCidLower 填好）， // 所以这里不需要再 needGuangyaHelper=false（让它保持原来值就行，computedCidObj 已填好就不会再走 3402 的 else if） } if (needGuangyaHelper) { // 如果 JSON 已经有合法 cid（直接用），就不用再调 helper 了；只有空才去下载计算 if (!computedCidObj || (!computedCidObj.tripleCid && !computedCidObj.wholeCid)) { console.log(`[光鸭秒传] 尝试为光鸭源 fileId=${row.fileId} 下载样本计算 cid（显式光鸭标记=${hasExplicitGuangyaTag}，fileId格式符合=${fileIdLooksGuangya}，JSON自带cid=${hasAnyValidJsonCid ? "有" : "无"}）`); } else { console.log(`[光鸭秒传] 光鸭源已有 JSON cid，跳过 helper 下载计算（cid=JSON自带）`); needGuangyaHelper = false; // 已有计算需求已满足 } } else if (isGuangyaSource && !fileIdLooksGuangya) { // 🔴 典型旧错标场景：迅雷 JSON 被旧脚本错误打了 sourceGuangya=true 但 fileId 不像光鸭 // 这种情况下，哪怕 panXunlei 没有可用 API，也绝对不能进光鸭 helper console.warn(`[光鸭秒传] 检测到旧脚本的错标 sourceGuangya，但 fileId=${String(row.fileId).slice(0,24)}… 格式不像光鸭 → 拒绝调用光鸭 helper（避免 404/空返回，后续只能 gcid+md5 探秒传）。请用新脚本重新提取迅雷 JSON 获取正确标记 + shareId/passCodeToken。`); // 兜底再试一次迅雷 getFileDetail（如果 panXunlei 可用，比如用户同时开着迅雷页） if (panXunlei && typeof panXunlei.getFileDetail === "function") { try { // 🔴 根因修复：分享页 JSON 的 shareId/passCodeToken 必须透传，否则 getFileDetail 只跑路径4（登录态） const xShare2 = String(row.shareId || "").trim(); const xPass2 = String(row.passCodeToken || "").trim(); console.log(`[光鸭秒传] 尝试作为迅雷源兜底调一次 getFileDetail（fileId=${String(row.fileId).slice(0,24)}… shareId=${xShare2 ? "有" : "无"}）`); const xDetail = await panXunlei.getFileDetail(row.fileId, xShare2, xPass2, { parentId: row.parentId || "" }); if (xDetail) { const tmpEntry = panXunlei._normalizeFileEntry(xDetail, row.filePath || "", row.parentId || ""); // 🔴 二次校验：排除图片 CDN（88cdn/backstage-img 等），避免补回来仍是图片链接 // 🔴 兜底：若 _normalizeFileEntry 没拿到 URL，用共享 flat scan 扫嵌套层 URL let tmpDl = (tmpEntry && tmpEntry.downloadUrl) ? tmpEntry.downloadUrl : ""; if (tmpDl && isImageCdnUrl(tmpDl)) tmpDl = ""; if (!tmpDl && panXunlei._extractDlFromDetailFlat) tmpDl = panXunlei._extractDlFromDetailFlat(xDetail); if (tmpDl && /^https?:\/\//i.test(tmpDl) && !isImageCdnUrl(tmpDl)) { computedSourceUrl = tmpDl; console.log(`[光鸭秒传] ✅ 迅雷兜底补到 downloadUrl → 继续算 cid（链接前缀：${String(tmpDl).slice(0, 60)}…）`); } } } catch (_ignore) { /* ignore */ } } } else { if (isGuangyaSource) { // 光鸭源但没进 helper → 一定是 fileId 不符合（15-25 位纯数字）或有迅雷特征字段 console.warn(`[光鸭秒传] 源判定为光鸭，但未触发 helper 下载 cid（原因：fileId=${String(row.fileId).slice(0,24)}… 格式=${fileIdLooksGuangya ? "符合光鸭" : "不像光鸭"}，迅雷特征=${rowLooksLikeXunlei ? "有" : "无"}，JSON 自带 cid=${hasAnyValidJsonCid ? "有" : "无"}）；仍会用 gcid+md5 和 JSON 兜底 cid 值继续探秒传`); } else { console.log(`[光鸭秒传] 跳过 cid 自动计算：fileId 非光鸭源（${String(row.fileId).slice(0,24)}…）且 JSON 不含 downloadUrl；仍将使用 gcid/md5 组合 + JSON 自带 cid 兜底尝试秒传`); } } } if (computedSourceUrl || needGuangyaHelper) { if (needGuangyaHelper && !computedSourceUrl && row.fileId) { console.log(`[光鸭秒传] 🚀 即将调 helper.downloadAndComputeCid：fileId=${row.fileId} size=${fileSizeNum} tokenLen=${String(token||"").length}`); try { computedCidObj = await helper.downloadAndComputeCid( row.fileId, fileSizeNum, token ); console.log(`[光鸭秒传] ✅ helper 返回：tripleCid=${computedCidObj?.tripleCid ? "有" : "无"} wholeCid=${computedCidObj?.wholeCid ? "有" : "无"} wholeFile=${computedCidObj?.wholeFileBuffer ? "有" : "无"} dlUrl=${computedCidObj?.downloadUrl ? "有" : "无"}`); } catch (helperErr) { console.error(`[光鸭秒传] ❌ helper.downloadAndComputeCid 抛异常：${String(helperErr && (helperErr.message || helperErr) || "").slice(0, 200)}`); computedCidObj = null; } } else if (computedSourceUrl && typeof panGuangya?._downloadByteRange === "function" && typeof panGuangya?.computeCidFromArrayBuffer === "function") { // 内联：迅雷源路径 —— 只需要 computedSourceUrl（它本身是带签名的公开 URL，无额外 headers） const dlSrc = computedSourceUrl; const downloadByte = (s, e) => panGuangya._downloadByteRange(dlSrc, s, e); let wholeFileBuffer = null; if (fileSizeNum <= WHOLE_FILE_MAX) { try { const r = await fetch(dlSrc, { method: "GET", mode: "cors", credentials: "omit" }); if (r && (r.status === 200 || r.status === 206)) wholeFileBuffer = await r.arrayBuffer(); } catch {} // fetch 可能因 CORS 失败（迅雷 CDN 不允许跨域），用 GM_xmlhttpRequest 兜底 if (!wholeFileBuffer) { wholeFileBuffer = await new Promise(resolve => { GM_xmlhttpRequest({ method: "GET", url: dlSrc, responseType: "arraybuffer", onload: (r) => resolve((r.status === 200 || r.status === 206) ? r.response : null), onerror: () => resolve(null), ontimeout: () => resolve(null), timeout: 120000, }); }); } } let combinedBuffer; if (wholeFileBuffer) { const u8 = new Uint8Array(wholeFileBuffer); const picks = []; if (fileSizeNum <= SAMPLE) picks.push(u8.slice(0, fileSizeNum), u8.slice(0, fileSizeNum), u8.slice(0, fileSizeNum)); else if (fileSizeNum <= SAMPLE * 2) { picks.push(u8.slice(0, SAMPLE)); const m = Math.floor(fileSizeNum / 3); picks.push(u8.slice(m, Math.min(m + SAMPLE, fileSizeNum))); picks.push(u8.slice(Math.max(0, fileSizeNum - SAMPLE), fileSizeNum)); } else { picks.push(u8.slice(0, SAMPLE)); const m = Math.floor(fileSizeNum / 3); picks.push(u8.slice(m, m + SAMPLE)); picks.push(u8.slice(fileSizeNum - SAMPLE, fileSizeNum)); } const total = picks.reduce((s, p) => s + p.length, 0); const cmb = new Uint8Array(total); let off = 0; for (const p of picks) { cmb.set(p, off); off += p.length; } combinedBuffer = cmb.buffer; } else { const ranges = []; ranges.push({ start: 0, end: SAMPLE - 1 }); const mid = Math.floor(fileSizeNum / 3); ranges.push({ start: mid, end: Math.min(mid + SAMPLE - 1, fileSizeNum - 1) }); const lastS = Math.max(0, fileSizeNum - SAMPLE); ranges.push({ start: lastS, end: fileSizeNum - 1 }); const bufs = []; for (const rr of ranges) { const ab = await downloadByte(rr.start, rr.end); if (ab && ab.byteLength > 0) bufs.push(ab); } if (bufs.length < 2) { computedCidObj = { tripleCid: "", wholeCid: "", downloadUrl: computedSourceUrl }; } else { const total = bufs.reduce((s, b) => s + (b.byteLength || 0), 0); const cmb = new Uint8Array(total); let off = 0; for (const b of bufs) { cmb.set(new Uint8Array(b), off); off += b.byteLength; } combinedBuffer = cmb.buffer; } } if (combinedBuffer) { const res = await panGuangya.computeCidFromArrayBuffer(combinedBuffer, fileSizeNum); const wholeCid = wholeFileBuffer ? await panGuangya.sha1Whole(wholeFileBuffer).catch(() => (res ? res.wholeCid : "")) : (res ? res.wholeCid : ""); computedCidObj = { tripleCid: res ? res.tripleCid : "", wholeCid: wholeCid || (res ? res.wholeCid : ""), wholeFileBuffer: wholeFileBuffer || undefined, downloadUrl: computedSourceUrl, }; } } } if (computedCidObj && computedCidObj.tripleCid && /^[0-9a-fA-F]{40}$/.test(computedCidObj.tripleCid)) { tripleCidLower = computedCidObj.tripleCid.toLowerCase(); tripleCidUpper = tripleCidLower.toUpperCase(); // 优先用 tripleCid 作为主 cidStr（符合迅雷标准） cidStr = tripleCidUpper; lowerCid = tripleCidLower; console.log(`[光鸭秒传] tripleCid 计算成功: ${cidStr}`); } if (computedCidObj && computedCidObj.wholeCid && /^[0-9a-fA-F]{40}$/.test(computedCidObj.wholeCid)) { wholeCidLower = computedCidObj.wholeCid.toLowerCase(); wholeCidUpper = wholeCidLower.toUpperCase(); console.log(`[光鸭秒传] wholeCid（整文件SHA-1）计算成功: ${wholeCidUpper}`); } if (computedCidObj && computedCidObj.wholeFileBuffer) { wholeFileBufferForUpload = computedCidObj.wholeFileBuffer; console.log(`[光鸭秒传] 已获取整个文件内容（${helper.formatSize(wholeFileBufferForUpload.byteLength)}），后续可用于OSS实际上传兜底`); } if (!cidStr && !wholeCidLower) { console.warn(`[光鸭秒传] cid 计算失败，将使用备用策略`); } // 🔁 终极 fallback：即使前面判定错了（比如旧脚本错把迅雷 JSON 标成了光鸭源）， // 只要 tripleCid+wholeCid 仍都空、且 panXunlei 可用且 row 有 fileId， // 就再无条尝试走迅雷 getFileDetail → 补 downloadUrl → 内联算 cid。 // 这一步不依赖任何 sourceGuangya/sourceXunlei 标记，也不丢任何误判，强行兜底 // （最多就是多 1 次 API 成本，但能救回老 JSON 的成功率。 if ((!tripleCidLower && !wholeCidLower) && !computedSourceUrl && row.fileId && panXunlei && typeof panXunlei.getFileDetail === "function" && typeof panXunlei._normalizeFileEntry === "function" && panGuangya && typeof panGuangya._downloadByteRange === "function" && typeof panGuangya.computeCidFromArrayBuffer === "function") { try { console.log(`[光鸭秒传] 🔁 cid仍缺失，启动迅雷兜底（不管标记）：fileId=${String(row.fileId).slice(0,24)}… shareId=${String(row.shareId||"").slice(0,8)}…`); const xShare = String(row.shareId || "").trim(); const xPass = String(row.passCodeToken || "").trim(); const xDetail = await panXunlei.getFileDetail(row.fileId, xShare, xPass, { parentId: row.parentId || "" }); let fallbackDl = ""; if (xDetail) { const tmpE = panXunlei._normalizeFileEntry(xDetail, row.filePath || "", row.parentId || ""); // 🔴 二次校验：排除图片 CDN（88cdn/backstage-img 等），避免补回来仍是图片链接 // 🔴 兜底：若 _normalizeFileEntry 没拿到 URL，用共享 flat scan 扫嵌套层 URL fallbackDl = (tmpE && tmpE.downloadUrl) ? tmpE.downloadUrl : ""; if (fallbackDl && isImageCdnUrl(fallbackDl)) fallbackDl = ""; if (!fallbackDl && panXunlei._extractDlFromDetailFlat) fallbackDl = panXunlei._extractDlFromDetailFlat(xDetail); if (isImageCdnUrl(fallbackDl)) fallbackDl = ""; } if (fallbackDl) { console.log(`[光鸭秒传] ✅ 迅雷兜底拿到 downloadUrl，重新内联算 cid（链接前缀：${String(fallbackDl).slice(0, 60)}…）`); const dlByte = (s, e) => panGuangya._downloadByteRange(fallbackDl, s, e); let wholeBuf = null; if (fileSizeNum <= WHOLE_FILE_MAX) { try { const rr = await fetch(fallbackDl, { method: "GET", mode: "cors", credentials: "omit" }); if (rr && (rr.status === 200 || rr.status === 206)) wholeBuf = await rr.arrayBuffer(); } catch (_b) { /* ignore */ } // fetch 可能因 CORS 失败（迅雷 CDN 不允许跨域），用 GM_xmlhttpRequest 兜底 if (!wholeBuf) { wholeBuf = await new Promise(resolve => { GM_xmlhttpRequest({ method: "GET", url: fallbackDl, responseType: "arraybuffer", onload: (r) => resolve((r.status === 200 || r.status === 206) ? r.response : null), onerror: () => resolve(null), ontimeout: () => resolve(null), timeout: 120000, }); }); } } let cbuf; if (wholeBuf) { const u82 = new Uint8Array(wholeBuf); const p2 = []; if (fileSizeNum <= SAMPLE) p2.push(u82.slice(0, fileSizeNum), u82.slice(0, fileSizeNum), u82.slice(0, fileSizeNum)); else if (fileSizeNum <= SAMPLE * 2) { const m = Math.floor(fileSizeNum / 3); p2.push( u82.slice(0, SAMPLE), u82.slice(m, Math.min(m + SAMPLE, fileSizeNum)), u82.slice(Math.max(0, fileSizeNum - SAMPLE), fileSizeNum) ); } else { const m = Math.floor(fileSizeNum / 3); p2.push(u82.slice(0, SAMPLE), u82.slice(m, m + SAMPLE), u82.slice(fileSizeNum - SAMPLE, fileSizeNum)); } const t2 = p2.reduce((s, p) => s + p.length, 0); const c2 = new Uint8Array(t2); let o2 = 0; for (const p of p2) { c2.set(p, o2); o2 += p.length; } cbuf = c2.buffer; } else { const ranges2 = [ { start: 0, end: SAMPLE - 1 }, { start: Math.floor(fileSizeNum / 3), end: Math.min(Math.floor(fileSizeNum / 3) + SAMPLE - 1, fileSizeNum - 1) }, { start: Math.max(0, fileSizeNum - SAMPLE), end: fileSizeNum - 1 }, ]; const b2 = []; for (const rr of ranges2) { try { const ab2 = await dlByte(rr.start, rr.end); if (ab2 && ab2.byteLength > 0) b2.push(ab2); } catch { /* ignore */ } } if (b2.length >= 2) { const tt2 = b2.reduce((s, b) => s + (b.byteLength || 0), 0); const cc2 = new Uint8Array(tt2); let oo2 = 0; for (const bb2 of b2) { cc2.set(new Uint8Array(bb2), oo2); oo2 += bb2.byteLength || 0; } cbuf = cc2.buffer; } } if (cbuf) { const fres = await panGuangya.computeCidFromArrayBuffer(cbuf, fileSizeNum); const fwc = wholeBuf ? await panGuangya.sha1Whole(wholeBuf).catch(() => (fres ? fres.wholeCid : "")) : (fres ? fres.wholeCid : ""); const fcObj = { tripleCid: fres ? fres.tripleCid : "", wholeCid: fwc || (fres ? fres.wholeCid : ""), wholeFileBuffer: wholeBuf || undefined, downloadUrl: fallbackDl, }; if (fcObj.tripleCid && /^[0-9a-fA-F]{40}$/.test(fcObj.tripleCid)) { tripleCidLower = String(fcObj.tripleCid).toLowerCase(); tripleCidUpper = tripleCidLower.toUpperCase(); cidStr = tripleCidUpper; lowerCid = tripleCidLower; console.log(`[光鸭秒传] ✅ 迅雷兜底 tripleCid 计算成功：${cidStr}`); } if (fcObj.wholeCid && /^[0-9a-fA-F]{40}$/.test(fcObj.wholeCid)) { wholeCidLower = String(fcObj.wholeCid).toLowerCase(); wholeCidUpper = wholeCidLower.toUpperCase(); console.log(`[光鸭秒传] ✅ 迅雷兜底 wholeCid（整文件SHA-1）计算成功：${wholeCidUpper}`); } if (fcObj.wholeFileBuffer) { wholeFileBufferForUpload = fcObj.wholeFileBuffer; console.log(`[光鸭秒传] ✅ 迅雷兜底拿到整文件内容（${helper.formatSize(wholeFileBufferForUpload.byteLength)}），后续OSS兜底可用`); } computedCidObj = fcObj; } else { // cbuf 没拿到（Range 全失败）→ 但至少把 fallbackDl 保留，后面 OSS 流式实际上传兜底还能用 if (!computedCidObj) computedCidObj = { downloadUrl: fallbackDl }; else computedCidObj.downloadUrl = fallbackDl; console.log(`[光鸭秒传] 迅雷兜底 cid 采样不足，但保留 downloadUrl（后续OSS流式上传兜底仍可使用）`); } } } catch (fallbackErr) { const _fe = fallbackErr && (fallbackErr.message || fallbackErr); console.warn(`[光鸭秒传] 迅雷兜底 fallback 异常：${_fe ? String(_fe).slice(0, 200) : "未知错误"}`); } } } catch (cidErr) { const _ce = cidErr && (cidErr.message || cidErr); console.warn(`[光鸭秒传] cid 计算异常: ${_ce ? String(_ce).slice(0, 200) : "未知错误"}`); // 🛡️ 异常兜底 1：如果前面已经通过 helper/内联路径拿到了 {downloadUrl, wholeFileBuffer}， // 即使 triple/whole cid 都空，也要保留这些内容 → OSS 实际上传兜底仍然可用 // （很多时候 helper 成功下载了文件，只是 computeCidFromArrayBuffer 抛了异常，此时 wholeFileBuffer 已经到手） try { if (computedCidObj && typeof computedCidObj === "object") { const hasDl = typeof computedCidObj.downloadUrl === "string" && /^https?:\/\//i.test(computedCidObj.downloadUrl); const hasBuf = computedCidObj.wholeFileBuffer && computedCidObj.wholeFileBuffer.byteLength > 0; if (hasDl) console.log(`[光鸭秒传] 🛡️ cid异常但downloadUrl已取到，OSS流式兜底仍可用（${String(computedCidObj.downloadUrl || "").slice(0,60)}…）`); if (hasBuf) { if (!wholeFileBufferForUpload) { wholeFileBufferForUpload = computedCidObj.wholeFileBuffer; console.log(`[光鸭秒传] 🛡️ cid异常但wholeFileBuffer已拿到，OSS整文件PUT兜底可用（${helper.formatSize(wholeFileBufferForUpload.byteLength)}）`); } } } } catch (_p) { /* ignore */ } // 🛡️ 异常兜底 2：用 JSON 自身带的 40-hex cid/wholeCid/tripleCid 填到 computedCidObj 作秒传探测 try { if (row && typeof row === "object") { const fc = (s) => typeof s === "string" && /^[0-9a-fA-F]{40}$/.test(s); const c1 = fc(row.cid); const c2 = fc(row.wholeCid); const c3 = fc(row.tripleCid); const anyValid40 = c1 || c2 || c3; if (anyValid40 && !computedCidObj) { computedCidObj = { tripleCid: (c3 ? String(row.tripleCid).toLowerCase() : (c1 ? String(row.cid).toLowerCase() : "")), wholeCid: (c2 ? String(row.wholeCid).toLowerCase() : (c1 ? String(row.cid).toLowerCase() : "")), }; console.warn(`[光鸭秒传] 🛡️ cid 计算异常兜底：用 JSON 自带 40-hex cid 继续（computedCidObj 已补齐）`); } if (c1 && !tripleCidLower) { tripleCidLower = String(row.cid).toLowerCase(); tripleCidUpper = tripleCidLower.toUpperCase(); } if (c2 && !wholeCidLower) { wholeCidLower = String(row.wholeCid).toLowerCase(); wholeCidUpper = wholeCidLower.toUpperCase(); } } } catch (_p) { /* ignore */ } } } // Step 1：get_res_center_token —— 区分来源，选对正确 cid 优先顺序： // · 迅雷提取 JSON（row.cid 有值）：row.cid 本身就是 tripleCid，迅雷索引优先用它 // · 光鸭提取 JSON（cid 是我们用 fileId 下载计算出来的）：wholeCid（整文件SHA-1）是光鸭自己的秒传索引，必须排最前 const isCidComputedFromGuangya = !!computedCidObj; // true = cid 是通过 downloadAndComputeCid 现场算出来的 const tokenCidList = []; if (isCidComputedFromGuangya) { // 光鸭提取的 JSON：wholeCid 先，tripleCid 后（和成功抓包完全一致的命中路径） if (wholeCidLower) tokenCidList.push(wholeCidLower, wholeCidUpper); if (tripleCidLower) tokenCidList.push(tripleCidLower, tripleCidUpper); // 🆘 兜底1：光鸭源 tripleCid 缺失但 wholeCid 存在 → 把 wholeCid 再当作 tripleCid 再试一遍（ // 有些小文件在某些版本 wholeCid 就是 gcid 索引；成功版 id=10 就是 wholeCid 命中） if (wholeCidLower && !tripleCidLower && !tokenCidList.includes(wholeCidLower.toLowerCase())) tokenCidList.push(wholeCidLower); // JSON 自带的 cid（如果下载计算前就有）放在最后，仅兜底 if (cidStr && !tokenCidList.includes(lowerCid)) tokenCidList.push(lowerCid); if (cidStr && cidStr !== lowerCid && !tokenCidList.includes(cidStr)) tokenCidList.push(cidStr); } else { // 迅雷提取 / 正常 JSON 自带 cid：先原 cid（tripleCid），再 wholeCid（仅当现场算出来且不同的话） if (cidStr) tokenCidList.push(lowerCid, cidStr); if (wholeCidLower && !tokenCidList.includes(wholeCidLower)) tokenCidList.push(wholeCidLower, wholeCidUpper); if (tripleCidLower && !tokenCidList.includes(tripleCidLower)) tokenCidList.push(tripleCidLower, tripleCidUpper); } // 🆘 兜底2：把 JSON 自身带的 cid/wholeCid/tripleCid（必须是合法 40-hex SHA-1）追加到 cid 候选 // 🔴 关键修复：光鸭后端只接受 40-hex 作为 cid 参数，32-hex（md5/gcid切片）会返回 code=112『参数错误』 // 因此 tryPushCid 严格只接受 40-hex，md5 只在 md5 参数位使用（_md5OnlyCombos），绝不作 cid // 🔴 关键修复②：cid 不能等于 gcid（gcid 是 Merkle root hash，不是文件内容 SHA-1） // 旧版提取脚本可能把 gcid 误填为 cid，导致 get_res_center_token 的 res.cid = gcid → 秒传必败 if (row) { const _gcidL = String(row.gcid || "").trim().toLowerCase(); const tryPushCid = (raw) => { if (typeof raw !== "string") return; const s = String(raw || "").trim(); if (!/^[0-9a-fA-F]{40}$/.test(s)) return; // 只接受 40-hex SHA-1 // 排除 gcid 值（gcid 不是真正的 cid） if (_gcidL && s.toLowerCase() === _gcidL) return; const l = s.toLowerCase(); const u = s.toUpperCase(); if (!tokenCidList.includes(l)) tokenCidList.push(l); if (u !== l && !tokenCidList.includes(u)) tokenCidList.push(u); }; tryPushCid(row.cid); tryPushCid(row.wholeCid); tryPushCid(row.tripleCid); // 🔴 已移除：tryPushCid(gcidStr) / tryPushCid(lowerGcid) —— gcid 不是 cid // 🔴 已移除：md5(32-hex) 当 cid → 后端 code=112 // 🔴 已移除：gcid.slice(0,32)/slice(8,40) → 32-hex 后端 code=112 } // 生成 gcid+cid 参数组合（每种 cid 都试 gcid 小写 / 大写两种） const resCombos = []; for (const c of tokenCidList) { resCombos.push({ capacity: 2, res: { gcid: lowerGcid, cid: c, fileSize: fileSizeNum } }); if (lowerGcid !== gcidStr) resCombos.push({ capacity: 2, res: { gcid: gcidStr, cid: c, fileSize: fileSizeNum } }); } // md5 也是一个关键索引（迅雷客户端实际上传路径就是 md5+gcid+size） // 当 md5 存在 / 由 gcid前32位兜底而来时，生成 md5 参数组合（capacity=2秒传模式） const md5Combos = []; if (md5Str) { // 最标准的迅雷秒传 4 要素组合：gcid + cid + md5 + fileSize for (const c of tokenCidList) { md5Combos.push({ capacity: 2, res: { gcid: lowerGcid, cid: c, md5: md5Str, fileSize: fileSizeNum } }); if (upperMd5 && upperMd5 !== md5Str) md5Combos.push({ capacity: 2, res: { gcid: lowerGcid, cid: c, md5: upperMd5, fileSize: fileSizeNum } }); } // 无 cid 时就 gcid + md5 + size（迅雷原始上传协议的最小集合） md5Combos.push({ capacity: 2, res: { gcid: lowerGcid, md5: md5Str, fileSize: fileSizeNum } }); if (upperMd5 && upperMd5 !== md5Str) md5Combos.push({ capacity: 2, res: { gcid: lowerGcid, md5: upperMd5, fileSize: fileSizeNum } }); // 最后兜底：只传 md5 + size（最宽松） md5Combos.push({ capacity: 2, res: { md5: md5Str, fileSize: fileSizeNum } }); } const getTokenCandidates = [ // 1. 真实cid（tripleCid / wholeCid × 大小 / 大小写）—— 最高优先级 ...resCombos, // 2. md5 组合（迅雷秒传路径，极重要——很多迅雷文件只有 md5+gcid+size 能命中索引） ...md5Combos, // 3. 只传 gcid，不传 cid（服务器按 gcid+size 匹配秒传 → 这是光鸭→光鸭的核心路径） { capacity: 2, res: { gcid: lowerGcid, fileSize: fileSizeNum } }, // 4. 无cid兜底：用 gcid前32位作为 md5 + fileSize（光鸭前端旧版默认格式） { capacity: 2, res: { md5: lowerGcid.slice(0, 32), fileSize: fileSizeNum } }, // 5. 最终兜底：capacity=1 普通上传路径（绝对最后才用，用了就不是秒传） { capacity: 1, res: { md5: md5Str || lowerGcid.slice(0, 32), fileSize: fileSizeNum } }, ].filter(Boolean); // 【安全加固】迅雷/光鸭后端「cid=gcid」和「cid=全零」这两种组合永远不会命中秒传索引， // 只会导致后续 check_can_flash_upload 发送无效请求 + 几十次 code=147 空轮询，必须移除。 // 如果 getTokenCandidates 中真实 cid 组合为空（resCombos 空），则需要后续逻辑提前判定是否有 OSS 兜底可能。 let tokenBody = null; let strTaskId = ""; let instantHitNow = false; for (let gi = 0; gi < getTokenCandidates.length; gi++) { try { const { data: tBody } = await helper.postJsonGuangya( GUANGYA_URL_GET_RES_CENTER_TOKEN, { ...getTokenCandidates[gi], name: row.fileName || guangyaBasenameFromPath(row.filePath), parentId: String(row.parentId || ""), }, token, { allowedBusinessCodes: [0, GUANGYA_CODE_RES_TOKEN_INSTANT] }, ); const code = tBody && tBody.code; if (code === GUANGYA_CODE_RES_TOKEN_INSTANT) { instantHitNow = true; tokenBody = tBody; break; } const tData = tBody && tBody.data; const tId = tData && (tData.taskId != null ? tData.taskId : tData.task_id); if (tId != null && tId !== "") { tokenBody = tBody; strTaskId = String(tId); break; } } catch { /* 失败继续下一种 */ } } if (instantHitNow) { instantHitCount += 1; aggTransferOk += 1; if (typeof onItemSuccess === "function") { try { onItemSuccess(successKey); } catch { /* ignore */ } } return; } if (!tokenBody || !strTaskId) { pushFailRow(row); return; } lastResp = tokenBody; // Step 2：check_can_flash_upload —— 必传 {taskId, gcid, cid, fileSize}；缺 cid 会 code=112 // 同样区分来源： // · 光鸭提取 JSON：wholeCid 先（和成功抓包一致——gcid小写+wholeCid小写就是命中项） // · 迅雷 JSON：原 tripleCid 先 let lastCheckResp = null; const checkCidList = []; if (isCidComputedFromGuangya) { if (wholeCidLower) checkCidList.push(wholeCidLower, wholeCidUpper); if (tripleCidLower) checkCidList.push(tripleCidLower, tripleCidUpper); if (cidStr && !checkCidList.includes(lowerCid)) checkCidList.push(lowerCid); if (cidStr && cidStr !== lowerCid && !checkCidList.includes(cidStr)) checkCidList.push(cidStr); } else { if (cidStr) { checkCidList.push(lowerCid); if (cidStr !== lowerCid) checkCidList.push(cidStr); } if (wholeCidLower && !checkCidList.includes(wholeCidLower)) checkCidList.push(wholeCidLower, wholeCidUpper); if (tripleCidLower && !checkCidList.includes(tripleCidLower)) checkCidList.push(tripleCidLower, tripleCidUpper); if (tripleCidUpper && !checkCidList.includes(tripleCidUpper)) checkCidList.push(tripleCidUpper); } // 去重 const _deduped = []; for (const c of checkCidList) { if (c && !_deduped.includes(c)) _deduped.push(c); } // 🆘 check_can_flash_upload 的 cid 兜底链（和 tokenCidList 完全一致）： // 如果 helper 没算出 cid（wholeCidLower/tripleCidLower/cidStr 全空）， // checkCidList 会空 → _checkCombos 空 → 只走 _md5OnlyCombos（无 cid）→ 秒传必败！ // 必须把 JSON 自带 cid/wholeCid/tripleCid 追加进来 // 🔴 关键修复：光鸭后端只接受 40-hex 作为 cid 参数，32-hex（md5/gcid切片）会返回 code=112 // 🔴 关键修复②：cid 不能等于 gcid（gcid 是 Merkle root hash，不是文件内容 SHA-1） if (_deduped.length === 0 && row && typeof row === "object") { const _gcidL = String(row.gcid || "").trim().toLowerCase(); const _tryPushCheck = (raw) => { if (typeof raw !== "string") return; const s = String(raw || "").trim(); if (!/^[0-9a-fA-F]{40}$/.test(s)) return; // 只接受 40-hex SHA-1 if (_gcidL && s.toLowerCase() === _gcidL) return; // 排除 gcid const l = s.toLowerCase(); const u = s.toUpperCase(); if (l && !_deduped.includes(l)) _deduped.push(l); if (u !== l && u && !_deduped.includes(u)) _deduped.push(u); }; _tryPushCheck(row.cid); _tryPushCheck(row.wholeCid); _tryPushCheck(row.tripleCid); // 🔴 已移除：_tryPushCheck(gcidStr) / _tryPushCheck(lowerGcid) —— gcid 不是 cid // 🔴 已移除：md5(32-hex) 当 cid → 后端 code=112 // 🔴 已移除：gcid.slice(0,32)/slice(8,40) → 32-hex 后端 code=112 if (_deduped.length > 0) { console.warn(`[光鸭秒传] 🛡️ check_can_flash_upload cid 兜底：helper 未算出 cid，用 JSON 自带 40-hex cid 继续（共 ${_deduped.length} 个候选）`); } } const _checkCombos = []; for (const c of _deduped) { _checkCombos.push({ taskId: strTaskId, gcid: lowerGcid, cid: c, fileSize: fileSizeNum }); if (lowerGcid !== gcidStr) _checkCombos.push({ taskId: strTaskId, gcid: gcidStr, cid: c, fileSize: fileSizeNum }); // 迅雷秒传索引：同步尝试 cid 组合 + md5（4 要素匹配） if (md5Str) { _checkCombos.push({ taskId: strTaskId, gcid: lowerGcid, cid: c, md5: md5Str, fileSize: fileSizeNum }); if (upperMd5 && upperMd5 !== md5Str) _checkCombos.push({ taskId: strTaskId, gcid: lowerGcid, cid: c, md5: upperMd5, fileSize: fileSizeNum }); } } // 无 cid 但有 md5 的兜底（迅雷源，只用 gcid + md5 + size 3要素匹配） const _md5OnlyCombos = []; if (md5Str) { _md5OnlyCombos.push({ taskId: strTaskId, gcid: lowerGcid, md5: md5Str, fileSize: fileSizeNum }); if (upperMd5 && upperMd5 !== md5Str) _md5OnlyCombos.push({ taskId: strTaskId, gcid: lowerGcid, md5: upperMd5, fileSize: fileSizeNum }); } const checkCandidates = [ ..._checkCombos, ..._md5OnlyCombos, // 【安全加固】已移除「cid=gcid」和「cid=全零」这两个在后端永不命中的假组合 // 保留 gcid+size 无 cid 的请求路径（通过 _md5OnlyCombos 已经涵盖了有 md5 的场景， // 这里额外补一条纯 gcid 不夹带假 cid 的兜底） ...(_checkCombos.length === 0 && _md5OnlyCombos.length === 0 ? [{ taskId: strTaskId, gcid: lowerGcid, fileSize: fileSizeNum }] : []), ].filter(Boolean); for (let ci = 0; ci < checkCandidates.length; ci++) { try { const { data: checkBody } = await helper.postJsonGuangya( GUANGYA_URL_CHECK_FLASH_UPLOAD, checkCandidates[ci], token, { allowedBusinessCodes: [0] }, ); lastCheckResp = checkBody; const canFlash = checkBody && checkBody.data && checkBody.data.canFlashUpload === true; if (canFlash) break; } catch (err) { let isParamError = false; try { const d = JSON.parse(String(err?.guangyaDetail || "{}")); if (d && d.responseBody && d.responseBody.code === 112) isParamError = true; if (d && d.httpStatus === 400) isParamError = true; } catch { /* ignore */ } const errMsg = String(err?.message || err || ""); if (/400|bind body failed|mismatch/i.test(errMsg)) isParamError = true; if (!isParamError) throw err; } } if (lastCheckResp) lastResp = lastCheckResp; // 判秒传成功条件： // 1) canFlashUpload === true → 命中秒传，直接成功 // 2) check_can_flash_upload 返回 {msg:"success", data:{taskId}} 但无 canFlashUpload // → 服务器正在后台处理秒传任务（如响应中 "文件上传中" code=147），需轮询 get_info_by_task_id const checkData = lastCheckResp && lastCheckResp.data; const canFlashUpload = checkData && checkData.canFlashUpload === true; const hasTaskIdFromCheck = checkData && checkData.taskId; let pollTaskId = ""; // 预判断：是否有 OSS 实际上传兜底的可能（用于提前跳过空轮询 / 提前触发实际上传） const canWholePut = !!wholeFileBufferForUpload; const rawSourceUrl = (computedCidObj && computedCidObj.downloadUrl) || (typeof row.downloadUrl === "string" && row.downloadUrl && /^https?:\/\//i.test(row.downloadUrl) ? row.downloadUrl : ""); const canStreamPut = !canWholePut && !!rawSourceUrl && fileSizeNum > 0; const hasOssFallbackPath = canWholePut || canStreamPut; // 是否有任何「真实 cid」参与过 check_can_flash_upload 请求？ // （注意：_checkCombos 只包含 cid 组合，_md5OnlyCombos 是无 cid 的 md5 组合，两者都空才叫完全没有真实 cid） const hadAnyRealCidProbe = _checkCombos.length > 0; // 调试：把每一步判定都打出来（用户抓包里只有 gcid/md5 没 cid 时，基本是 canStreamPut=false → 没有实际上传） if (!hasOssFallbackPath && !hadAnyRealCidProbe) { console.warn(`[光鸭秒传] ⚠️ 文件 ${String(row.filePath || "").slice(0,60)}：既没真实cid组合，也没OSS实际上传源 → 这一轮几乎必败。 · hadAnyRealCidProbe=${hadAnyRealCidProbe}（_checkCombos.length=${_checkCombos.length}） · canWholePut=${canWholePut}（wholeFileBufferForUpload byteLength=${wholeFileBufferForUpload ? wholeFileBufferForUpload.byteLength : 0}） · canStreamPut=${canStreamPut}（rawSourceUrl=${rawSourceUrl ? String(rawSourceUrl).slice(0,60)+"…" : "空（导入端没拿到迅雷/光鸭的下载链接）"}） · gcid=${gcidStr || "(空)"} · 建议：用新脚本重新从迅雷页面提取 JSON（会写 sourceXunlei+shareId/passCodeToken 行级注入，成功率高），或确认迅雷 enrich 日志里 dlOK 非 0。`); } if (canFlashUpload) { // 情况1：明确返回 canFlashUpload:true，直接用返回的 taskId 轮询（100% 会命中，给足 30+30 轮询） pollTaskId = checkData.taskId || strTaskId; } else if (hasTaskIdFromCheck) { // 情况2：check_can_flash_upload 只返回 taskId 没有 canFlashUpload // → 如果既没有真实 cid 探测过，又没有 OSS 兜底路径，就判定为必败，直接删任务退出，避免空轮询 120 秒 pollTaskId = String(hasTaskIdFromCheck); if (!hadAnyRealCidProbe && !hasOssFallbackPath) { console.warn(`[光鸭秒传] 跳过空轮询：check 未命中 canFlashUpload、无真实cid组合、也无OSS兜底可能 → 秒传必败，直接失败（文件:${String(row.filePath || "").slice(0,60)}）`); try { await helper.postJsonGuangya(GUANGYA_URL_DELETE_UPLOAD_TASK, { taskIds: [pollTaskId] }, token); } catch { /* ignore */ } pushFailRow(row); return; } console.log(`[光鸭秒传] check_can_flash_upload 无 canFlashUpload 但有 taskId=${pollTaskId}（有${hadAnyRealCidProbe?"真实cid兜底":"仅md5组合探测"}，OSS兜底:${hasOssFallbackPath?"有":"无"}），开始轮询...`); } else { // 情况3：既无 canFlashUpload 也无 taskId → 真正的失败 try { await helper.postJsonGuangya(GUANGYA_URL_DELETE_UPLOAD_TASK, { taskIds: [strTaskId] }, token); } catch { /* ignore */ } pushFailRow(row); return; } // 轮询 get_info_by_task_id let pollOk = false; const MAX_POLL = 30; let didOssFallbackAttempt = false; for (let pi = 0; pi < MAX_POLL; pi++) { try { const { data: pollBody } = await helper.postJsonGuangya( GUANGYA_URL_GET_INFO_BY_TASK_ID, { taskId: String(pollTaskId) }, token, { allowedBusinessCodes: [0, 145, 146, 147, 155, 163] }, ); if (pollBody && pollBody.data && (pollBody.data.fileId || (pollBody.code === 0 && pollBody.data))) { pollOk = true; break; } } catch { /* 继续重试 */ } // 兜底策略：触发 OSS 实际上传 // · 有 OSS 兜底路径时，**提前到第 3 次轮询** 就触发实际上传（不再浪费时间等秒传命中） // · ≤100MB 且有整文件 buffer → 一次性 PUT // · >100MB 且有源下载 URL → 按块流式 Range 下载 + PUT（Content-Range 分片） const triggerAt = hadAnyRealCidProbe ? 8 : 2; // 有真实cid探测就等到第9次；没有就第3次立刻实际上传 if (!didOssFallbackAttempt && pi >= triggerAt && !pollOk && tokenBody && tokenBody.data && hasOssFallbackPath) { didOssFallbackAttempt = true; try { console.log(`[光鸭秒传] 轮询 ${pi+1}/${MAX_POLL} 仍未完成，提前触发 OSS 实际上传兜底（${canWholePut ? "小文件整文件PUT" : "大文件流式8MB/块"}）...`); let putOk = false; if (canWholePut) { putOk = await helper.tryUploadOssDirectPut(wholeFileBufferForUpload, tokenBody.data); } else { putOk = await helper.tryUploadOssStreaming(rawSourceUrl, fileSizeNum, tokenBody.data); } console.log(`[光鸭秒传] OSS 实际上传兜底结果：${putOk ? "成功 ✓" : "失败（不影响，继续轮询）"}`); } catch (ossErr) { console.warn(`[光鸭秒传] OSS 实际上传兜底异常：${String(ossErr?.message || ossErr).slice(0, 200)}`); } } await helper.sleep(500); } // 如果首轮 30 次轮询未成功，但我们做了 OSS 实际上传，再额外轮询（大文件流式上传本身耗时较长，给足后端处理时间） if (!pollOk && didOssFallbackAttempt) { const extraPolls = canWholePut ? 20 : 90; console.log(`[光鸭秒传] 首轮轮询结束但OSS兜底已执行，追加 ${extraPolls} 秒轮询等待后端转存...`); for (let pi = 0; pi < extraPolls; pi++) { try { const { data: pollBody } = await helper.postJsonGuangya( GUANGYA_URL_GET_INFO_BY_TASK_ID, { taskId: String(pollTaskId) }, token, { allowedBusinessCodes: [0, 145, 146, 147, 155, 163] }, ); if (pollBody && pollBody.data && (pollBody.data.fileId || (pollBody.code === 0 && pollBody.data))) { pollOk = true; break; } } catch { /* ignore */ } await helper.sleep(500); } } if (pollOk) { instantHitCount += 1; aggTransferOk += 1; if (typeof onItemSuccess === "function") { try { onItemSuccess(successKey); } catch { /* ignore */ } } } else { // 轮询超时才清理任务 try { await helper.postJsonGuangya(GUANGYA_URL_DELETE_UPLOAD_TASK, { taskIds: [pollTaskId || strTaskId] }, token); } catch { /* ignore */ } pushFailRow(row); } } else { // md5 秒传路径 const { data: apiBody } = await helper.postJsonGuangya( GUANGYA_URL_GET_RES_CENTER_TOKEN, { capacity: 1, res: { md5: row.md5, fileSize: row.fileSize }, name: row.fileName || guangyaBasenameFromPath(row.filePath), parentId: String(row.parentId || "") }, token, { allowedBusinessCodes: [0, GUANGYA_CODE_RES_TOKEN_INSTANT] }, ); lastResp = apiBody; const code = apiBody && apiBody.code; if (code === GUANGYA_CODE_RES_TOKEN_INSTANT) { instantHitCount += 1; aggTransferOk += 1; if (typeof onItemSuccess === "function") { try { onItemSuccess(successKey); } catch { /* ignore */ } } } else { const d = apiBody && apiBody.data; const tid = d && (d.taskId != null ? d.taskId : d.task_id != null ? d.task_id : ""); if (tid !== "" && tid != null) { try { await helper.postJsonGuangya(GUANGYA_URL_DELETE_UPLOAD_TASK, { taskIds: [String(tid)] }, token); } catch { /* ignore */ } } pushFailRow(row); } } } catch (apiErr) { if (isGuangyaForbiddenNameError(apiErr)) { skip.push(`${row.filePath}：文件名含违禁词，已跳过（${String(apiErr.message || "").slice(0, 200)}）`); return; } pushFailRow(row); apiErr.partialTransferFailures = transferFailedEntries.slice(); apiErr.importFailedAtProbeIndex = fi + 1; if (!_firstError) _firstError = apiErr; return; } }; // 启动 worker pool：每个 worker 从队列里取下一个文件处理，直到全部完成 let _nextIdx = 0; const _workers = []; for (let _w = 0; _w < CONCURRENCY; _w++) { _workers.push((async () => { while (true) { const fi = _nextIdx++; if (fi >= payloadFiles.length) break; await _processOneFile(fi); } })()); } await Promise.all(_workers); if (_firstError) throw _firstError; const transferFailedMissingDetail = aggTransferFail > 0 && transferFailedEntries.length === 0; return { resp: lastResp, skipCount: skip.length, okCount: payloadFiles.length, skipped: skip, importSummary: { batchCount: 0, probeTotal, instantHitCount, mkdirFailedCount, transferSuccess: aggTransferOk, transferFail: aggTransferFail, skipCount: skip.length, transferFailedEntries, transferFailedMissingDetail, }, }; }, // -------------------------------------------------------- // 提取秒传 JSON（从光鸭云盘当前账号） // -------------------------------------------------------- /** 从文件对象中兼容地取 md5/etag/gcid（原始字符串，不区分类型） */ _pickMd5FromFile(f) { const raw = f?.md5 ?? f?.etag ?? f?.Md5 ?? f?.MD5 ?? f?.fileMd5 ?? f?.hash ?? f?.fileHash ?? f?.gcid ?? ""; return String(raw || "").trim(); }, /** * 通过 fileId 从本地缓存（响应拦截器捕获的真实列表响应）直接取出 cid/wholeCid/gcid/md5/downloadUrl * 无需下载文件内容计算 cid，是最准确、最快的方式 * 返回 { tripleCid, wholeCid, gcid, md5, downloadUrl } 或空对象 */ getCidFromFileId(fileId) { const id = String(fileId || "").trim(); if (!id) return {}; try { // 优先：拦截器建立的 fileId 索引 const cached = panGuangya._cachedFileIdMap?.[id]; if (cached && typeof cached === "object") { const c = panGuangya._pickCidFromFile(cached); const g = String(cached.gcid || cached.etag || cached.md5 || "").trim(); const md = String(cached.md5 || "").trim(); const dl = String(cached.downloadUrl || cached.url || cached.download_link || "").trim(); return { tripleCid: c.tripleCid || "", wholeCid: c.wholeCid || "", gcid: /^[0-9A-Fa-f]{40}$/.test(g) ? g.toUpperCase() : "", md5: /^[0-9A-Fa-f]{32}$/.test(md) ? md.toLowerCase() : "", downloadUrl: dl, _sourceFile: cached, }; } // 兜底：在最近缓存的列表中线性查找 const list = panGuangya._cachedCurrentList || []; for (const f of list) { const fid = panGuangya._pickIdFromFile(f); if (fid && fid === id) { const c = panGuangya._pickCidFromFile(f); return { tripleCid: c.tripleCid || "", wholeCid: c.wholeCid || "", gcid: /^[0-9A-Fa-f]{40}$/.test(String(f.gcid || "")) ? String(f.gcid).toUpperCase() : "", md5: /^[0-9A-Fa-f]{32}$/.test(String(f.md5 || "")) ? String(f.md5).toLowerCase() : "", downloadUrl: String(f.downloadUrl || f.url || "").trim(), _sourceFile: f, }; } } } catch { /* ignore */ } return {}; }, /** 从文件对象中独立提取 cid（cid 是文件的采样 SHA-1，与 gcid 不同！） */ _pickCidFromFile(f) { if (!f || typeof f !== "object") return { tripleCid: "", wholeCid: "" }; // 兼容各种字段名：cid / sampleCid / sampleFileCid / sampling_hash / chunkSampleHash // 光鸭 API 实际可能还返回 tripleCid / chunkHash / tripleSha1 / wholeSha1 / wholeCid / sha1 / fileSha1 const candidateFields = [ "cid", "sampleCid", "sampleFileCid", "sampling_hash", "chunkSampleHash", "CID", "Cid", "tripleCid", "triple_cid", "tripleSha1", "triple_sha1", "sampleSha1", "sample_sha1", "chunkSha1", "chunkCid", "chunk_cid", "chunkHash", "chunk_hash", ]; const wholeFields = [ "wholeCid", "whole_cid", "wholeSha1", "whole_sha1", "sha1", "sha_1", "SHA1", "fileSha1", "file_sha1", "fileCid", "file_cid", "fullSha1", "full_sha1", ]; function firstHex40(obj, fields) { for (const k of fields) { const v = obj?.[k]; if (typeof v === "string" && /^[0-9a-fA-F]{40}$/.test(v)) return v.trim(); } return ""; } // 优先找专门的 triple/whole 字段 let triple = firstHex40(f, ["tripleCid", "triple_cid", "tripleSha1", "sampleSha1", "chunkCid", "chunkHash", "cid"]); let whole = firstHex40(f, ["wholeCid", "whole_cid", "wholeSha1", "sha1", "fileSha1", "fullSha1"]); // 如果只有一个 cid 字段，不知道是 triple 还是 whole，都作为 triple 填，whole 为空（后面会再做计算） if (!triple) { const raw = f.cid ?? f.sampleCid ?? f.sampleFileCid ?? f.sampling_hash ?? f.chunkSampleHash ?? f.CID ?? f.Cid ?? ""; const s = String(raw || "").trim(); if (/^[0-9A-Fa-f]{40}$/.test(s)) triple = s; } // 兜底：如果 wholeCid 为空但 triple 有，且 API 还返回了另一个不同的 40 hex，那就是 wholeCid if (!whole) { const all40 = new Set(); for (const [k, v] of Object.entries(f)) { if (typeof v === "string" && /^[0-9a-fA-F]{40}$/.test(v) && v.toLowerCase() !== String(f?.gcid || "").toLowerCase()) { all40.add(v.toLowerCase()); } } const tripleLower = triple.toLowerCase(); for (const h of all40) { if (h !== tripleLower) { whole = h; break; } } } return { tripleCid: /^[0-9A-Fa-f]{40}$/.test(triple) ? triple.toUpperCase() : "", wholeCid: /^[0-9A-Fa-f]{40}$/.test(whole) ? whole.toUpperCase() : "", }; }, /** 判断哈希字符串类型：返回 'gcid'（40位十六进制） / 'md5'（32位十六进制） / 'unknown'（其他） */ _classifyHash(hashStr) { const s = String(hashStr || "").trim(); if (!s) return "unknown"; if (/^[0-9A-Fa-f]{40}$/.test(s)) return "gcid"; if (/^[0-9A-Fa-f]{32}$/.test(s)) return "md5"; return "unknown"; }, /** 根据哈希类型构建提取 JSON 的 entry 对象（gcid→走 gcid 字段，md5→走 etag 字段） * cidInfo 接受字符串（向后兼容）或 { tripleCid, wholeCid } 对象 */ _buildExtractEntry(filePath, hashStr, size, cidInfo, extraFields = {}) { const entry = { path: filePath, size: size }; const hashType = panGuangya._classifyHash(hashStr); if (hashType === "gcid") entry.gcid = hashStr.toUpperCase(); else entry.etag = hashStr; // cidInfo 兼容旧版字符串（tripleCid）和新版对象 let triple = ""; let whole = ""; if (typeof cidInfo === "string") { triple = cidInfo.trim(); } else if (cidInfo && typeof cidInfo === "object") { triple = String(cidInfo.tripleCid || cidInfo.cid || "").trim(); whole = String(cidInfo.wholeCid || "").trim(); } if (/^[0-9A-Fa-f]{40}$/.test(triple)) entry.cid = triple.toUpperCase(); if (/^[0-9A-Fa-f]{40}$/.test(whole)) entry.wholeCid = whole.toUpperCase(); // 附加字段：fileId（光鸭文件ID，用于下载样本计算cid）、parentId、dirType等 for (const [k, v] of Object.entries(extraFields)) { if (v != null && String(v).trim() !== "") entry[k] = String(v).trim(); } // 兜底：如果 fileId 在 extraFields 里没有（传入空值）， // 直接从 extraFields 的 __sourceFile 回退对象里提取（如果有传的话） if (!entry.fileId && extraFields.__sourceFile) { const f = extraFields.__sourceFile; const recoveredId = panGuangya._pickIdFromFile(f); if (recoveredId) { console.warn("[光鸭提取] _buildExtractEntry 兜底：从源文件对象恢复 fileId", { 恢复值: recoveredId, 源文件键: Object.keys(f).join(", ") }); entry.fileId = recoveredId; } } return entry; }, _pickNameFromFile(f) { return String(f?.fileName ?? f?.file_name ?? f?.name ?? f?.Name ?? "").trim(); }, _pickSizeFromFile(f) { const n = Number(f?.fileSize ?? f?.size ?? f?.Size ?? 0); return Number.isFinite(n) && n >= 0 ? n : 0; }, _pickIdFromFile(f) { if (!f || typeof f !== "object") return ""; // 注意：parentId/parent_id 表示父目录，不能作为文件自身的ID // 按优先级尝试各种可能的 id 字段名 const idFields = [ "fileId", "file_id", "fid", "fileID", "Fid", "FID", "dirId", "dir_id", "dirID", "directoryId", "directory_id", "folderId", "folder_id", "folderID", "id", "Id", "ID", "nodeId", "node_id", "nodeID", "catalogId", "catalog_id", "resourceId", "resource_id", "objId", "obj_id", "objectId", "object_id", "uuid", "UUID", "guid", "GUID", "pk", "PK", "key", "vid", "videoId", "docId", "originId", "origin_id", "uploadId", "upload_id", ]; function tryPick(obj, depth) { if (!obj || typeof obj !== "object") return ""; if (depth > 2) return ""; // 最多深入 2 层防止无限递归 for (const k of idFields) { const v = obj[k]; if (v != null && String(v).trim() !== "") { const s = String(v).trim(); if (s.length >= 1 && /[a-zA-Z0-9_-]/.test(s)) { return s.replace(/[-_]+$/, ""); } } } // 回退：任何看起来像ID的字段（排除parentId/parent_id等） const keys = Object.keys(obj); for (const k of keys) { if (/id/i.test(k) && k !== "parentId" && k !== "parent_id" && k !== "pid" && !/parent/i.test(k)) { const v = obj[k]; if (v != null && String(v).trim() !== "") { const s = String(v).trim(); if (s.length >= 1 && /[a-zA-Z0-9_-]/.test(s)) { return s; } } } } // 深度搜索：原始对象可能在 .raw/.data/.info/.file 里 const nestedKeys = ["raw", "data", "info", "file", "source", "original", "origin", "detail", "item"]; for (const nk of nestedKeys) { const sub = obj[nk]; if (sub && typeof sub === "object" && !Array.isArray(sub)) { const subId = tryPick(sub, depth + 1); if (subId) return subId; } } return ""; } const res = tryPick(f, 0); if (res) return res; // 调试：输出文件对象的所有键，便于排查 const keys = Object.keys(f); const hasIdLikeKey = keys.some(k => /id/i.test(k)); if (hasIdLikeKey) { console.log("[光鸭提取] _pickIdFromFile 未匹配到ID字段，文件对象键:", keys.join(", "), "原始值预览:", JSON.stringify(f).slice(0, 400)); } else { console.warn("[光鸭提取] _pickIdFromFile 警告：API返回的文件对象中甚至没有任何 id 类字段！", "键:", keys.join(", "), "原始值:", JSON.stringify(f).slice(0, 500)); } return ""; }, _isFolder(f) { if (!f || typeof f !== "object") return false; // 明确的文件夹标识（优先级最高） // type/kind 字段 const t = String(f?.type ?? f?.Type ?? f?.fileType ?? f?.file_type ?? f?.kind ?? ""); if (t === "folder" || t === "FOLDER" || t === "drive#folder" || t === "dir" || t === "DIR") return true; if (t === "0" || t === 0) return true; // 很多网盘 type=0 是文件夹 // isDir / isFolder / isDirectory 标志 if (f?.isDir === true || f?.isDirectory === true || f?.isFolder === true) return true; if (f?.isDir === false || f?.isDirectory === false || f?.isFolder === false) return false; // 子文件/子目录计数字段 if (f?.childCount != null || f?.children != null || f?.fileCount != null || f?.subCount != null) return true; if (f?.child_num != null || f?.childNum != null) return true; // fileCategory / category if (f?.fileCategory != null || f?.category != null) { const cat = String(f?.fileCategory ?? f?.category); if (cat === "folder" || cat === "dir" || cat === "0" || cat === "folderType") return true; if (cat === "file" || cat === "1" || cat === "2" || cat === "fileType") return false; } // 明确的文件标识：有有效 md5/etag/gcid → 一定是文件 const hasValidHash = !!( (f?.md5 && /^[a-f0-9]{32}$/i.test(String(f.md5))) || (f?.etag && /^[a-f0-9]{32}$/i.test(String(f.etag))) || (f?.gcid && /^[a-f0-9]{40}$/i.test(String(f.gcid))) ); if (hasValidHash) return false; // 只有 dirId/folderId 且没有 fileId/id → 可能是文件夹 const hasDirId = f?.dirId != null || f?.folderId != null; const hasFileId = f?.fileId != null || f?.id != null; if (hasDirId && !hasFileId) return true; // 有 size 且 > 0 → 更可能是文件 const size = Number(f?.fileSize ?? f?.size ?? 0); const name = String(f?.fileName ?? f?.name ?? f?.Name ?? ""); if (size > 0) { // 有大小且有扩展名 → 基本是文件 if (name && /\.[a-zA-Z0-9]{1,10}$/.test(name)) return false; // 有大小但无扩展名 → 可能是无扩展名的文件，暂判为文件 return false; } // size 为 0 或不存在 → 可能是文件夹也可能是空文件 // 无扩展名 → 更可能是文件夹 if (name && !/\.[a-zA-Z0-9]{1,10}$/.test(name)) { // 有 hash → 文件 if (f?.md5 || f?.etag || f?.hash || f?.gcid) return false; // 无 hash 且无扩展名 → 文件夹 return true; } // 有扩展名但 size=0 → 可能是空文件 if (name && /\.[a-zA-Z0-9]{1,10}$/.test(name)) return false; return false; }, /** 从接口响应中兼容地取文件列表数组 */ _pickFileListFromResp(j) { if (!j) return []; const d = j.data ?? j; if (Array.isArray(d)) return d; if (d && typeof d === "object") { if (Array.isArray(d.list)) return d.list; if (Array.isArray(d.files)) return d.files; if (Array.isArray(d.fileList)) return d.fileList; if (Array.isArray(d.infoList)) return d.infoList; if (Array.isArray(d.Infos)) return d.Infos; if (Array.isArray(d.records)) return d.records; } if (Array.isArray(j.list)) return j.list; if (Array.isArray(j.files)) return j.files; return []; }, _pickNextPageToken(j) { const d = j?.data ?? j; return d?.nextPageToken ?? d?.next_page_token ?? d?.nextToken ?? d?.pageToken ?? j?.next_page_token ?? ""; }, /** 从响应中提取总数 */ _pickTotalCount(j) { const d = j?.data ?? j; const total = d?.total ?? d?.totalCount ?? d?.total_count ?? d?.count ?? d?.size ?? d?.length ?? j?.total ?? j?.totalCount; if (total != null) { const n = Number(total); if (Number.isFinite(n) && n >= 0) return n; } return null; }, /** * 调用光鸭云盘文件列表接口，返回 { files, nextPageToken }。 * 使用响应拦截器捕获的真实 endpoint；若未捕获则用默认 GUANGYA_URL_FILE_LIST。 * pageTokenOrNum: 字符串=pageToken模式，数字=page模式 */ async _fetchFileList(parentId, pageTokenOrNum) { const token = await panGuangya.getAccessToken(); const url = panGuangya._cachedListUrlTemplate; if (!url) { throw new Error( "未捕获到光鸭云盘文件列表请求。\n" + "请先在光鸭云盘页面中点击进入任意文件夹（触发文件列表加载），再点击「提取JSON」。" ); } const method = panGuangya._cachedListMethod || "GET"; // 空字符串或undefined → 第一页，不带分页参数（与原始页面请求一致） // 数字或纯数字字符串 → page分页模式 // 非数字字符串 → pageToken分页模式 const argStr = String(pageTokenOrNum || "").trim(); const isPageMode = argStr !== "" && /^\d+$/.test(argStr); const isTokenMode = argStr !== "" && !isPageMode; const pageNum = isPageMode ? Number(argStr) : 0; const pageToken = isTokenMode ? argStr : ""; console.log("[光鸭提取] _fetchFileList", { parentId, method, isPageMode, pageNum, pageToken, 模板URL: url, 检测到的parentId参数: panGuangya._cachedParentIdParam || "(未检测到)", 检测到的分页参数: panGuangya._cachedPageParam || "(未检测到)", 请求体模板: panGuangya._cachedListBodyTemplate ? JSON.stringify(panGuangya._cachedListBodyTemplate).slice(0, 300) : "(无)" }); let j; if (method === "POST") { // POST 方式：用捕获的请求体模板，替换 parentId const body = panGuangya.buildListBody(parentId, pageToken, pageNum); console.log("[光鸭提取] POST 请求", { URL: url, body: JSON.stringify(body).slice(0, 300) }); const ret = await helper.postJsonGuangya(url, body, token, { allowedBusinessCodes: [0] }); j = ret.data; } else { // GET 方式：用捕获的 URL 模板，替换 parentId let fullUrl = panGuangya.buildListUrl(parentId); if (pageToken) { if (/[?&]pageToken=([^&]*)/i.test(fullUrl)) { fullUrl = fullUrl.replace(/([?&]pageToken=)[^&]*/i, `$1${encodeURIComponent(pageToken)}`); } else { fullUrl += `&pageToken=${encodeURIComponent(pageToken)}`; } } if (isPageMode && pageNum > 0) { // page 分页方式（仅后续页）：优先使用检测到的参数名 const sep = fullUrl.includes("?") ? "&" : "?"; const pageParam = panGuangya._cachedPageParam || "page"; fullUrl += `${sep}${pageParam}=${pageNum}`; const sizeParam = panGuangya._cachedPageSizeParam || "pageSize"; const hasSizeKey = new RegExp(`[?&]${sizeParam.replace(/([.*+?^=!:${}()|\[\]\/\\])/g, "\\$1")}=`, "i").test(fullUrl); if (!hasSizeKey) { fullUrl += `&${sizeParam}=100`; } } // 第一页（isPageMode=false, isTokenMode=false）不加任何分页参数，与原始页面请求一致 console.log("[光鸭提取] GET 请求", { 完整URL: fullUrl }); j = await helper.getGuangya(fullUrl, token); } console.log("[光鸭提取] API 响应", { 响应预览: JSON.stringify(j).slice(0, 500), 提取的文件数: panGuangya._pickFileListFromResp(j).length }); // 计算下一页标识 let nextPageToken = panGuangya._pickNextPageToken(j); let nextPageNum = 0; const respFiles = panGuangya._pickFileListFromResp(j); const total = panGuangya._pickTotalCount(j); if (nextPageToken) { // API 返回了 nextPageToken，用它翻页 } else if (isPageMode) { // page 分页模式：检查是否有更多数据 if (total == null) { // 无法确定总数时，如果返回了满页数据，假设还有下一页 if (respFiles.length >= 100) { nextPageNum = pageNum + 1; } } else if (total > pageNum * 100) { nextPageNum = pageNum + 1; } } else if (isTokenMode) { // pageToken 分页模式，但没有 nextPageToken → 没有更多数据 } else { // 第一页（无分页参数）：如果有 total 且文件数 < total，需要用 page=2 翻页 if (total != null && respFiles.length > 0 && respFiles.length < total) { nextPageNum = 2; } } return { files: respFiles, nextPageToken: nextPageToken || (nextPageNum > 0 ? nextPageNum : ""), raw: j }; }, async getFilesInFolder(parentId, pathPrefix, onProgress) { console.log("[光鸭提取] getFilesInFolder 开始", { parentId, pathPrefix }); const results = []; let pageToken = ""; let pageNum = 1; // 当前页码，第一页用空字符串请求（不带page参数） let retryCount = 0; let isFirstPage = true; do { try { // 第一页：传空字符串（与原始页面请求一致，不带page参数） // 后续页：优先用 nextPageToken，没有则用 pageNum let fetchArg; if (isFirstPage) { fetchArg = ""; // 第一页不带分页参数 } else if (pageToken) { fetchArg = pageToken; // 有 nextPageToken 用它 } else { fetchArg = pageNum; // 没有 nextPageToken，用页码 } console.log("[光鸭提取] _fetchFileList 调用", { parentId, arg: fetchArg, isFirstPage, pageNum }); const { files, nextPageToken, raw } = await panGuangya._fetchFileList(parentId, fetchArg); console.log("[光鸭提取] _fetchFileList 返回", { 文件数: files.length, nextPageToken: nextPageToken || "(无)", 首个文件: files[0] ? JSON.stringify(files[0]).slice(0, 300) : "(空)" }); for (const f of files) { if (panGuangya._isFolder(f)) { const subFid = panGuangya._pickIdFromFile(f); const subName = panGuangya._pickNameFromFile(f); console.log("[光鸭提取] 发现子文件夹", { 名称: subName, ID: subFid, 原始对象: JSON.stringify(f).slice(0, 300) }); if (!subFid) { console.warn("[光鸭提取] 无法提取子文件夹ID，跳过", f); continue; } const subPath = pathPrefix ? `${pathPrefix}/${subName}` : subName; const subFiles = await panGuangya.getFilesInFolder(subFid, subPath, onProgress); results.push(...subFiles); } else { const hash = panGuangya._pickMd5FromFile(f); const name = panGuangya._pickNameFromFile(f); if (!name) continue; const cidVal = panGuangya._pickCidFromFile(f); const filePath = pathPrefix ? `${pathPrefix}/${name}` : name; const fid = panGuangya._pickIdFromFile(f); const pid = f?.parentId != null ? String(f.parentId) : ""; const entry = panGuangya._buildExtractEntry(filePath, hash, panGuangya._pickSizeFromFile(f), cidVal, { fileId: fid, parentId: pid, __sourceFile: f }); if (!entry.fileId) { console.warn("[光鸭提取] 条目缺少 fileId，原始文件对象键:", Object.keys(f).join(", "), "文件预览:", JSON.stringify(f).slice(0, 400)); } results.push(entry); } } pageToken = nextPageToken; if (!isFirstPage) pageNum++; else pageNum = 2; // 第一页之后是第二页 retryCount = 0; isFirstPage = false; } catch (e) { console.error("[光鸭提取] getFilesInFolder 错误", { parentId, pathPrefix, error: e?.message || e }); // 第一页失败必须抛出（说明文件夹ID或API有问题） if (isFirstPage && retryCount >= 2) { throw new Error(`获取文件夹列表失败：${pathPrefix || parentId}\n原因：${e?.message || e}\n\n请按 F12 打开浏览器控制台查看详细日志。`); } // 后续页失败，重试最多 2 次 if (retryCount < 2) { retryCount++; await helper.sleep(500); continue; } // 超过重试次数，跳过这一页 console.warn("光鸭云盘文件夹列表获取失败，跳过：", parentId, e?.message || e); break; } if (onProgress) onProgress(results.length); if (!pageToken) break; } while (pageToken); console.log("[光鸭提取] getFilesInFolder 完成", { parentId, pathPrefix, 总文件数: results.length }); return results; }, /** * 获取所有被勾选的行（DOM元素数组） * 同时兼容原生 checkbox 和 Ant Design / Element UI 等伪 checkbox */ _getCheckedRows() { const rows = []; const seen = new Set(); function addRow(row) { if (!row || seen.has(row)) return; // 过滤表头、侧边栏等非数据行 if (row.closest("nav, header, [class*='nav' i], [class*='menu' i], [class*='sidebar' i], [class*='breadcrumb' i], thead, th, .ant-table-thead")) return; seen.add(row); rows.push(row); } // -------- 1) 原生 checkbox :checked -------- try { const nativeCbs = document.querySelectorAll("input[type='checkbox']:checked"); for (const cb of nativeCbs) { const row = cb.closest("tr, [class*='file-item'], [class*='file-row'], [class*='list-item'], [class*='item' i], li, [class*='row']"); if (row) addRow(row); } } catch {} // -------- 2) Ant Design 伪 checkbox（ant-checkbox-checked，最常见） -------- try { const antChecked = document.querySelectorAll( ".ant-checkbox-checked, [class*='checkbox'][class*='checked' i], " + "[class*='check-box'][class*='checked' i], [class*='chk'][class*='checked' i]" ); for (const cb of antChecked) { const row = cb.closest("tr, [class*='file-item'], [class*='file-row'], [class*='list-item'], [class*='item' i], li, [class*='row']"); if (row) addRow(row); } } catch {} // -------- 3) 自定义图标 checkbox（选中图标 / SVG / 背景色高亮） -------- try { // 选中样式的行（整行高亮） const selectedRows = document.querySelectorAll( ".ant-table-row-selected, tr.ant-table-row[class*='selected' i], " + "[class*='file-item'][class*='selected' i], [class*='file-item'][class*='active' i], " + "[class*='file-row'][class*='selected' i], [class*='file-row'][class*='active' i], " + "[class*='list-item'][class*='selected' i], [class*='list-item'][class*='active' i]" ); for (const row of selectedRows) addRow(row); } catch {} // -------- 4) aria-checked="true"（无障碍伪 checkbox） -------- try { const ariaChecked = document.querySelectorAll("[aria-checked='true']"); for (const el of ariaChecked) { const row = el.closest("tr, [class*='file-item'], [class*='file-row'], [class*='list-item'], [class*='item' i], li, [class*='row']"); if (row) addRow(row); } } catch {} // -------- 5) 兜底：找第一列里带对号图标的单元格 -------- try { // 可能是 SVG
${preview.replace(//g, ">")}`)); return; } // 尝试 JSON 解析 try { resolve(JSON.parse(text)); } catch (e) { const preview = text.length > 300 ? text.substring(0, 300) + "..." : text; // 检测是否返回了 HTML 页面（如 Cloudflare 验证、反爬等） const isHtml = /^[\s\S]*<(!DOCTYPE|html|head|body)/i.test(text); const reason = isHtml ? "服务器返回了 HTML 页面（可能是反爬验证、接口变更或被拦截）" : "响应内容不是合法 JSON"; reject(new Error(`${reason}
状态码: ${status} | ${preview.replace(//g, ">")}`)); } }, onerror: () => reject(new Error("网络错误（无法连接到搜索服务器）")), ontimeout: () => reject(new Error("请求超时（服务器响应过慢，请稍后重试）")), timeout: 60000, }); } else { const ctrl = new AbortController(); const t = setTimeout(() => { ctrl.abort(); reject(new Error("请求超时（服务器响应过慢，请稍后重试）")); }, 60000); fetch(url, { headers: { "Accept": "application/json" }, signal: ctrl.signal }) .then(async (r) => { const text = await r.text(); if (!r.ok) { const preview = text.length > 200 ? text.substring(0, 200) + "..." : text; throw new Error(`HTTP ${r.status} 错误
${preview.replace(//g, ">")}`); } try { return JSON.parse(text); } catch (e) { const preview = text.length > 300 ? text.substring(0, 300) + "..." : text; const isHtml = /^[\s\S]*<(!DOCTYPE|html|head|body)/i.test(text); const reason = isHtml ? "服务器返回了 HTML 页面（可能是反爬验证、接口变更或被拦截）" : "响应内容不是合法 JSON"; throw new Error(`${reason}
${preview.replace(//g, ">")}`); } }) .then((d) => { clearTimeout(t); resolve(d); }) .catch((e) => { clearTimeout(t); reject(e); }); } }); }, show() { const mask = document.createElement("div"); mask.style.cssText = "position:fixed;inset:0;background:rgba(0,0,0,.5);z-index:2147483646;display:flex;align-items:center;justify-content:center;"; const popup = document.createElement("div"); popup.style.cssText = "width:90%;max-width:720px;background:#fff;border-radius:12px;box-shadow:0 20px 60px rgba(0,0,0,.3);display:flex;flex-direction:column;max-height:95vh;overflow-y:auto;"; popup.onclick = (e) => e.stopPropagation(); mask.onclick = () => mask.remove(); const header = document.createElement("div"); header.style.cssText = "display:flex;align-items:center;gap:12px;padding:16px 20px;border-bottom:1px solid #eee;"; const searchInput = document.createElement("input"); searchInput.type = "text"; searchInput.placeholder = "输入关键词搜索资源（支持迅雷/阿里/百度/夸克/磁力等）"; searchInput.style.cssText = "flex:1;padding:8px 12px;border:1px solid #ddd;border-radius:8px;font-size:14px;outline:none;"; const searchBtn = document.createElement("button"); searchBtn.textContent = "搜索"; searchBtn.style.cssText = "padding:8px 20px;border:none;border-radius:8px;background:#1677ff;color:#fff;cursor:pointer;font-size:14px;"; const closeBtn = document.createElement("button"); closeBtn.textContent = "✕"; closeBtn.style.cssText = "padding:4px 10px;border:none;background:none;cursor:pointer;font-size:18px;color:#999;"; closeBtn.onclick = () => mask.remove(); header.appendChild(searchInput); header.appendChild(searchBtn); header.appendChild(closeBtn); popup.appendChild(header); const tabsBar = document.createElement("div"); tabsBar.style.cssText = "display:none;flex-wrap:wrap;gap:8px;padding:12px 20px;border-bottom:1px solid #f0f0f0;"; let currentTab = "all"; let lastKeyword = ""; const renderTabs = () => { tabsBar.innerHTML = ""; // 只显示有结果的标签（除了"全部"始终显示） const visibleTabs = this.tabs.filter((t) => t.id === "all" || t.count > 0); for (const tab of visibleTabs) { const el = document.createElement("span"); el.textContent = tab.name + (tab.count ? ` (${tab.count})` : ""); el.style.cssText = `padding:6px 14px;border-radius:20px;cursor:pointer;font-size:13px;white-space:nowrap;transition:.2s;${currentTab === tab.id ? `background:${tab.color || "#1677ff"};color:#fff;` : "background:#f5f5f5;color:#666;"}`; el.onclick = () => { currentTab = tab.id; renderTabs(); renderResults(); }; tabsBar.appendChild(el); } }; popup.appendChild(tabsBar); const resultsList = document.createElement("div"); resultsList.style.cssText = "flex:1;min-height:200px;max-height:50vh;overflow-y:auto;padding:12px 20px;"; popup.appendChild(resultsList); let allResults = []; const renderResults = () => { resultsList.innerHTML = ""; const list = currentTab === "all" ? allResults : allResults.filter((r) => r.type === currentTab); if (list.length === 0) { resultsList.innerHTML = `

暂无匹配结果

`; return; } // 按日期递减排序（最新的在前） const sorted = [...list].sort((a, b) => { const da = a.date || ""; const db = b.date || ""; return db.localeCompare(da); }); for (const item of sorted) { const card = document.createElement("div"); card.style.cssText = "padding:12px;border:1px solid #f0f0f0;border-radius:8px;margin-bottom:8px;cursor:pointer;transition:.2s;display:flex;justify-content:space-between;align-items:flex-start;"; card.onmouseenter = () => { card.style.borderColor = "#1677ff"; card.style.boxShadow = "0 2px 8px rgba(22,119,255,.15)"; }; card.onmouseleave = () => { card.style.borderColor = "#f0f0f0"; card.style.boxShadow = "none"; }; const info = document.createElement("div"); const title = document.createElement("div"); title.textContent = item.title; title.style.cssText = "font-size:14px;font-weight:600;color:#222;margin-bottom:6px;"; info.appendChild(title); const meta = document.createElement("div"); meta.style.cssText = "display:flex;gap:8px;align-items:center;flex-wrap:wrap;font-size:12px;color:#888;"; if (item.source) { const s = document.createElement("span"); s.textContent = item.source; s.style.cssText = "padding:2px 8px;background:#e3f2fd;border-radius:4px;color:#1976d2;"; meta.appendChild(s); } if (item.date) { const d = document.createElement("span"); d.textContent = item.date; meta.appendChild(d); } if (item.password) { const p = document.createElement("span"); p.textContent = `提取码:${item.password}`; p.style.cssText = "color:#ff5722;"; meta.appendChild(p); } info.appendChild(meta); card.appendChild(info); const actions = document.createElement("div"); actions.style.cssText = "display:flex;gap:6px;"; // 磁力链接：额外添加“云添加”按钮，跳转到光鸭云盘自动填入并提交 const isMagnet = item.type === "magnet" || (item.url && item.url.startsWith("magnet:")); if (isMagnet) { const cloudAddBtn = document.createElement("button"); cloudAddBtn.textContent = "云添加"; cloudAddBtn.style.cssText = "padding:4px 12px;border:1px solid #1677ff;border-radius:4px;font-size:12px;cursor:pointer;color:#1677ff;background:#fff;transition:.2s;"; cloudAddBtn.onmouseenter = () => { cloudAddBtn.style.background = "#1677ff"; cloudAddBtn.style.color = "#fff"; }; cloudAddBtn.onmouseleave = () => { cloudAddBtn.style.background = "#fff"; cloudAddBtn.style.color = "#1677ff"; }; cloudAddBtn.onclick = (e) => { e.stopPropagation(); // 存入待添加的磁力链接，跳转光鸭云盘主页 try { GM_setValue(KEY_GUANGYA_PENDING_MAGNET, item.url); } catch { /* ignore */ } const orig = cloudAddBtn.textContent; cloudAddBtn.textContent = "✓ 跳转中"; setTimeout(() => { cloudAddBtn.textContent = orig; }, 1200); setTimeout(() => { if (typeof GM_openInTab === "function") { GM_openInTab("https://guangyapan.com/", { active: true, insert: true }); } else { window.open("https://guangyapan.com/", "_blank"); } }, 300); }; actions.appendChild(cloudAddBtn); } const copyBtn = document.createElement("button"); copyBtn.textContent = "复制"; copyBtn.style.cssText = "padding:4px 12px;border:1px solid #d9d9d9;border-radius:4px;font-size:12px;cursor:pointer;color:#666;background:#fff;transition:.2s;"; copyBtn.onmouseenter = () => { copyBtn.style.borderColor = "#1677ff"; copyBtn.style.color = "#1677ff"; }; copyBtn.onmouseleave = () => { copyBtn.style.borderColor = "#d9d9d9"; copyBtn.style.color = "#666"; }; copyBtn.onclick = (e) => { e.stopPropagation(); const text = item.password ? `${item.url} 提取码:${item.password}` : item.url; if (typeof GM_setClipboard !== "undefined") { GM_setClipboard(text, "text"); const orig = copyBtn.textContent; copyBtn.textContent = "✓ 已复制"; copyBtn.style.color = "#4caf50"; copyBtn.style.borderColor = "#4caf50"; setTimeout(() => { copyBtn.textContent = orig; copyBtn.style.color = "#666"; copyBtn.style.borderColor = "#d9d9d9"; }, 1000); } else { navigator.clipboard?.writeText(text); } }; actions.appendChild(copyBtn); card.appendChild(actions); card.onclick = () => { if (item.url) { window.open(item.url, "_blank"); } }; resultsList.appendChild(card); } }; resultsList.innerHTML = `

输入关键词开始搜索

`; const doSearch = async () => { const kw = searchInput.value.trim(); if (!kw) return; lastKeyword = kw; searchBtn.disabled = true; searchBtn.textContent = "搜索中..."; resultsList.innerHTML = `

搜索中，首次搜索需聚合多个来源，可能需 10-30 秒...

`; try { allResults = await this.search(kw, 1, currentTab === "all" ? "" : currentTab); currentTab = "all"; if (allResults.length > 0) { tabsBar.style.display = "flex"; renderTabs(); } else { tabsBar.style.display = "none"; } renderResults(); } catch (e) { resultsList.innerHTML = `

搜索失败
${e?.message || "请稍后重试"}

`; } finally { searchBtn.disabled = false; searchBtn.textContent = "搜索"; } }; searchBtn.onclick = doSearch; searchInput.addEventListener("keydown", (e) => { if (e.key === "Enter") doSearch(); }); searchInput.focus(); document.body.appendChild(mask); mask.appendChild(popup); }, }; // ============================================================ // 按钮注入 // ============================================================ function injectGuangyaButtonTypographyStyles() { if (document.getElementById(GUANGYA_BTN_TYPO_STYLE_ID)) return; const st = document.createElement("style"); st.id = GUANGYA_BTN_TYPO_STYLE_ID; st.textContent = "#" + BTN_GUANGYA_IMPORT_ID + ",#" + BTN_GUANGYA_EXTRACT_ID + ",#" + BTN_GUANGYA_SEARCH_ID + "{font-family:-apple-system,BlinkMacSystemFont,\"Segoe UI\",Roboto,\"Helvetica Neue\",Arial," + "\"PingFang SC\",\"Hiragino Sans GB\",\"Microsoft YaHei\",sans-serif !important;}"; (document.head || document.documentElement).appendChild(st); } function makeGuangyaButton(label, color, onClick, idAttr) { const btn = document.createElement("button"); btn.id = idAttr; btn.type = "button"; btn.style.cssText = "box-sizing:border-box;display:inline-flex;align-items:center;justify-content:center;" + "height:36px;min-height:36px;padding:0 14px;margin-right:8px;" + "border-radius:8px;white-space:nowrap;cursor:pointer;vertical-align:middle;" + `background:${color} !important;border:1px solid ${color} !important;color:#fff !important;` + "font-size:13px;line-height:1.45;font-weight:500;"; const span = document.createElement("span"); span.textContent = label; btn.appendChild(span); btn.onclick = () => { try { onClick(); } catch (e) { alert(e?.message || String(e)); } }; return btn; } function resolveGuangyaToolbarButtons() { const uploadBtn = document.querySelector(".swangpan-icon-upload").closest("button"); const newFolderBtn = document.querySelector(".swangpan-icon-addfolder").closest("button"); if (uploadBtn && newFolderBtn) { return { uploadBtn, newFolderBtn, toolbarRow: uploadBtn.parentElement }; } const nodes = document.querySelectorAll("button.ant-btn"); let uBtn = null, fBtn = null; for (const el of nodes) { const text = (el.textContent || "").replace(/\s+/g, ""); if (text.includes("上传")) uBtn = el; if (text.includes("新建文件夹")) fBtn = el; if (uBtn && fBtn) break; } if (uBtn && fBtn) return { uploadBtn: uBtn, newFolderBtn: fBtn, toolbarRow: uBtn.parentElement }; return null; } function tryMountGuangyaButtons() { injectGuangyaButtonTypographyStyles(); const container = resolveGuangyaToolbarButtons(); // 顺序：导入JSON, 提取JSON, 搜索资源, 记录状态 // 使用 beforebegin 插入到新建文件夹按钮前面，保证顺序正确 if (container) { // 导入 JSON 按钮 if (!document.getElementById(BTN_GUANGYA_IMPORT_ID)) { const importBtn = makeGuangyaButton("导入JSON", "#ff9800", () => panGuangya.showImportDialog(), BTN_GUANGYA_IMPORT_ID); importBtn.style.marginRight = "8px"; container.newFolderBtn.insertAdjacentElement("beforebegin", importBtn); } // 提取 JSON 按钮 if (!document.getElementById(BTN_GUANGYA_EXTRACT_ID)) { const extractBtn = makeGuangyaButton("提取JSON", "#1677ff", async () => { const span = extractBtn.querySelector("span"); const oldText = span ? span.textContent : ""; try { if (span) span.textContent = "提取中..."; extractBtn.disabled = true; await generateGuangya(); } catch (e) { alert(e?.message || "提取失败"); } finally { if (span) span.textContent = oldText; extractBtn.disabled = false; } }, BTN_GUANGYA_EXTRACT_ID); extractBtn.style.marginRight = "8px"; container.newFolderBtn.insertAdjacentElement("beforebegin", extractBtn); } // 搜索资源按钮 if (!document.getElementById(BTN_GUANGYA_SEARCH_ID)) { const searchBtn = makeGuangyaButton("搜索资源", "#43a047", () => resourceSearch.show(), BTN_GUANGYA_SEARCH_ID); searchBtn.style.marginRight = "8px"; container.newFolderBtn.insertAdjacentElement("beforebegin", searchBtn); } // 记录状态按钮 if (!document.getElementById(BTN_GUANGYA_RECORD_ID)) { const recordBtn = makeGuangyaButton("记录状态", "#9c27b0", () => panGuangya.recordStatus(), BTN_GUANGYA_RECORD_ID); recordBtn.style.marginRight = "8px"; container.newFolderBtn.insertAdjacentElement("beforebegin", recordBtn); } } else { // 兜底：浮动按钮 if (!document.getElementById(BTN_GUANGYA_IMPORT_ID)) { const importBtn = makeGuangyaButton("导入JSON", "#ff9800", () => panGuangya.showImportDialog(), BTN_GUANGYA_IMPORT_ID); importBtn.style.cssText += "position:fixed;left:24px;top:24px;z-index:2147483647;box-shadow:0 6px 20px rgba(0,0,0,.2);"; document.body.appendChild(importBtn); } if (!document.getElementById(BTN_GUANGYA_EXTRACT_ID)) { const extractBtn = makeGuangyaButton("提取JSON", "#1677ff", async () => { const span = extractBtn.querySelector("span"); const oldText = span ? span.textContent : ""; try { if (span) span.textContent = "提取中..."; extractBtn.disabled = true; await generateGuangya(); } catch (e) { alert(e?.message || "提取失败"); } finally { if (span) span.textContent = oldText; extractBtn.disabled = false; } }, BTN_GUANGYA_EXTRACT_ID); extractBtn.style.cssText += "position:fixed;left:24px;top:68px;z-index:2147483647;box-shadow:0 6px 20px rgba(0,0,0,.2);"; document.body.appendChild(extractBtn); } if (!document.getElementById(BTN_GUANGYA_SEARCH_ID)) { const searchBtn = makeGuangyaButton("搜索资源", "#43a047", () => resourceSearch.show(), BTN_GUANGYA_SEARCH_ID); searchBtn.style.cssText += "position:fixed;left:24px;top:112px;z-index:2147483647;box-shadow:0 6px 20px rgba(0,0,0,.2);"; document.body.appendChild(searchBtn); } if (!document.getElementById(BTN_GUANGYA_RECORD_ID)) { const recordBtn = makeGuangyaButton("记录状态", "#9c27b0", () => panGuangya.recordStatus(), BTN_GUANGYA_RECORD_ID); recordBtn.style.cssText += "position:fixed;left:24px;top:156px;z-index:2147483647;box-shadow:0 6px 20px rgba(0,0,0,.2);"; document.body.appendChild(recordBtn); } } } function createButton() { if (panXunlei.isHost()) { if (panXunlei.isSharePage()) panXunlei.injectShareButton(); else panXunlei.injectButton(); return; } if (panGuangya.isHost()) { tryMountGuangyaButtons(); return; } } // 欢迎弹窗：显示联系方式图片 function showWelcomeDialog() { // 防止重复弹窗 if (document.getElementById('sumuve-welcome-dialog')) return; const overlay = document.createElement('div'); overlay.id = 'sumuve-welcome-dialog'; overlay.style.cssText = 'position:fixed;inset:0;background:rgba(0,0,0,.45);z-index:999999;display:flex;align-items:center;justify-content:center;font-family:-apple-system,BlinkMacSystemFont,"PingFang SC","Microsoft YaHei",sans-serif;'; const box = document.createElement('div'); box.style.cssText = 'background:#fff;border-radius:12px;padding:24px;width:92vw;max-width:420px;box-shadow:0 12px 40px rgba(0,0,0,.25);display:flex;flex-direction:column;align-items:center;'; // 仅当配置了图片 Base64 时才创建 img 元素，避免空 src 导致破图 let img = null; if (__WELCOME_IMG_BASE64__) { img = document.createElement('img'); img.src = __WELCOME_IMG_BASE64__; img.style.cssText = 'width:100%;max-width:360px;border-radius:8px;margin-bottom:16px;'; img.alt = '脚本开发联系方式'; } const text = document.createElement('div'); text.textContent = '脚本代开发请联系作者sumuve'; text.style.cssText = 'font-size:15px;color:#262626;margin-bottom:18px;font-weight:500;'; const btn = document.createElement('button'); btn.textContent = '确定'; btn.style.cssText = 'padding:8px 32px;background:linear-gradient(135deg,#ff7a45,#ffb84d);color:#fff;border:none;border-radius:8px;font-size:14px;font-weight:600;cursor:pointer;box-shadow:0 4px 12px rgba(255,122,69,.4);'; btn.onmouseenter = () => { btn.style.opacity = '.9'; }; btn.onmouseleave = () => { btn.style.opacity = '1'; }; btn.onclick = () => overlay.remove(); if (img) box.appendChild(img); box.appendChild(text); box.appendChild(btn); overlay.appendChild(box); // 点击遮罩也可关闭 overlay.addEventListener('click', (e) => { if (e.target === overlay) overlay.remove(); }); (document.body || document.documentElement).appendChild(overlay); } // -------------------------------------------------------- // 续跑提醒：读取 GM 持久化的未完成进度，在迅雷页/光鸭页弹提示 // （页面被切后台被冻结 / 刷新 / 关闭后重新打开时使用） // -------------------------------------------------------- function showSaveProgressResumeToast() { // 只在迅雷页（保存操作发生页）提示，避免光鸭页干扰 if (!panXunlei.isHost()) return; // 已存在当前加载弹窗不重复提醒 if (document.getElementById("guangya-loading-dialog")) return; if (document.getElementById("guangya-save-resume-toast")) return; let savedProgress = null; try { const rawProg = GM_getValue(KEY_GUANGYA_SAVE_PROGRESS, ""); if (rawProg && typeof rawProg === "string" && rawProg.trim()) { savedProgress = JSON.parse(rawProg); } } catch { savedProgress = null; } const hasPending = savedProgress && savedProgress.phase !== "done" && savedProgress.totalFiles && (Date.now() - (savedProgress.updatedAt || 0) < 1000 * 60 * 60 * 24); // 24 小时内 if (!hasPending) return; const totalN = Number(savedProgress.totalFiles) || 0; let doneN = 0; try { const arr = GM_getValue(KEY_GUANGYA_SAVE_SUCCESS_SET, "[]"); doneN = Array.isArray(arr) ? arr.length : (JSON.parse(String(arr)) || []).length; } catch { /* ignore */ } const pct = totalN > 0 ? Math.floor((doneN / totalN) * 100) : 0; const phaseText = savedProgress.phase === "mkdir" ? "创建目录阶段" : savedProgress.phase === "probe" ? "秒传阶段" : savedProgress.phase === "error" ? "出错中断" : "进行中"; const toast = document.createElement("div"); toast.id = "guangya-save-resume-toast"; toast.style.cssText = [ "position:fixed", "top:16px", "right:16px", "background:#fff7ed", "border:1px solid #ffbb96", "border-radius:10px", "padding:12px 16px", "box-shadow:0 6px 20px rgba(0,0,0,.12)", "z-index:2147483646", "font-family:-apple-system,BlinkMacSystemFont,'PingFang SC','Microsoft YaHei',sans-serif", "max-width:360px", "font-size:13px", "color:#5c3b1f", "line-height:1.6", ].join(";") + ";"; toast.innerHTML = `

检测到未完成的秒传任务

状态：${phaseText}

进度：${doneN} / ${totalN}（${pct}%）

请重新勾选相同文件 → 点击「提取JSON」→「保存」，
脚本会询问是否跳过已成功的 ${doneN} 条续跑。

`; document.body.appendChild(toast); const closeBtn = document.getElementById("guangya-save-toast-close"); if (closeBtn) closeBtn.onclick = () => toast.remove(); // 15 秒后自动消失 setTimeout(() => { if (toast.parentNode) toast.remove(); }, 15000); } function init() { if (!panGuangya.isHost() && !panXunlei.isHost()) return; const obsRoot = document.body || document.documentElement; if (!obsRoot) return; // 清理旧版抓包 UI 面板（如有） try { __captureRemoveUI(); } catch (e) { console.error("[光鸭秒传工具] 清理UI失败:", e); } // 进入网页时显示欢迎/联系弹窗 try { showWelcomeDialog(); } catch (e) { console.error("[光鸭秒传工具] 欢迎弹窗异常:", e); } injectGuangyaButtonTypographyStyles(); // 若存在待云添加的磁力链接，启动自动流程 if (panGuangya.isHost()) { try { autoCloudAddPendingMagnet(); } catch (e) { console.error("[光鸭提取] 自动云添加异常:", e); } } // 切回当前标签页/页面重新可见时，检查续跑 document.addEventListener("visibilitychange", () => { if (document.visibilityState === "visible") { try { showSaveProgressResumeToast(); } catch { /* ignore */ } } }); // 首次进入页面如果是迅雷页，也检查一次 try { showSaveProgressResumeToast(); } catch { /* ignore */ } let createButtonTimer = null; let isCreating = false; const debouncedCreateButton = () => { if (createButtonTimer) clearTimeout(createButtonTimer); createButtonTimer = setTimeout(() => { if (isCreating) return; isCreating = true; try { createButton(); } catch (e) { console.error("[光鸭秒传工具] createButton error:", e); } finally { isCreating = false; } }, 100); }; const observer = new MutationObserver(debouncedCreateButton); observer.observe(obsRoot, { childList: true, subtree: true }); createButton(); [400, 1500, 4000, 8000].forEach((ms) => setTimeout(createButton, ms)); } // 自动云添加：读取待处理的磁力链接，自动点击云添加按钮 → 填入文本框 → 点击确定 function autoCloudAddPendingMagnet() { let magnet = ""; try { magnet = GM_getValue(KEY_GUANGYA_PENDING_MAGNET, "") || ""; } catch { /* ignore */ } if (!magnet) return; // 立即清空，避免重复触发 try { GM_setValue(KEY_GUANGYA_PENDING_MAGNET, ""); } catch { /* ignore */ } console.log("[光鸭提取] 检测到待云添加磁力链接，开始自动流程:", magnet); // 等待选择器出现的工具函数（带超时） const waitFor = (selectorFn, timeout = 15000, interval = 300) => new Promise((resolve, reject) => { const start = Date.now(); const timer = setInterval(() => { const el = selectorFn(); if (el) { clearInterval(timer); resolve(el); return; } if (Date.now() - start > timeout) { clearInterval(timer); reject(new Error("等待元素超时")); } }, interval); }); // 模拟原生输入（兼容 React/Vue 受控组件） const setNativeValue = (el, value) => { const proto = el.tagName === "TEXTAREA" ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype; const setter = Object.getOwnPropertyDescriptor(proto, "value")?.set; if (setter) setter.call(el, value); else el.value = value; el.dispatchEvent(new Event("input", { bubbles: true })); el.dispatchEvent(new Event("change", { bubbles: true })); }; (async () => { try { // 1. 等待并点击“云添加”按钮（ant-btn 文本含“云添加”且不是下拉项） const cloudAddBtn = await waitFor(() => { const btns = document.querySelectorAll("button.ant-btn"); for (const b of btns) { if (b.textContent.trim().includes("云添加")) return b; } return null; }, 20000); cloudAddBtn.click(); console.log("[光鸭提取] 已点击云添加按钮"); // 2. 等待文本框出现并填入磁力链接 const textarea = await waitFor(() => { const tas = document.querySelectorAll("textarea"); for (const t of tas) { if (t.placeholder && t.placeholder.includes("下载链接")) return t; } return null; }, 15000); setNativeValue(textarea, magnet); console.log("[光鸭提取] 已填入磁力链接"); // 3. 等待并点击“确定”按钮 const confirmBtn = await waitFor(() => { const spans = document.querySelectorAll("span.swangpan-button__content"); for (const s of spans) { if (s.textContent.trim() === "确定") { // 向上查找可点击的 button 或父节点 let node = s; for (let i = 0; i < 6; i++) { node = node.parentElement; if (!node) break; if (node.tagName === "BUTTON" || node.getAttribute("role") === "button") return node; } return s; } } return null; }, 15000); confirmBtn.click(); console.log("[光鸭提取] 已点击确定按钮，云添加流程完成"); } catch (e) { console.error("[光鸭提取] 自动云添加失败:", e.message); // 失败时回填磁力链接，方便用户手动粘贴 try { GM_setValue(KEY_GUANGYA_PENDING_MAGNET, magnet); } catch { /* ignore */ } } })(); } if (typeof GM_registerMenuCommand === "function") { try { // 调试工具 toggle（持久化状态） const TOGGLE_KEY = "__gy_debug_menu_enabled__"; let debugEnabled = false; try { debugEnabled = GM_getValue(TOGGLE_KEY, false); } catch {} const TOGGLE_NAME = "🔧 调试工具（开启/关闭）"; function toggleDebugMenu() { // 先确保子菜单项已注册（ScriptCat 不支持注销，所以子菜单始终存在于列表中） __captureRegisterChildMenusOnce(); const newVal = !__captureDebugEnabled; __captureSetDebugEnabled(newVal); try { GM_setValue(TOGGLE_KEY, newVal); } catch {} if (newVal) { alert( "✅ 调试工具已开启！\n\n" + "ScriptCat 菜单中现在可使用：\n" + "📥 导出抓包JSON\n" + "🗑️ 清空抓包数据\n\n" + "再次点 🔧 调试工具即可关闭。" ); } else { alert( "🔕 调试工具已关闭。\n\n" + "📥 和 🗑️ 菜单项仍显示在 ScriptCat 中，\n" + "但在关闭状态下点击会提示未开启。\n\n" + "（ScriptCat 不支持动态注销菜单项，这是其技术限制。）" ); } } // ===== 注册顺序：🔧 toggle 必须放第一个，再注册 📥/🗑️ 子菜单项 ===== GM_registerMenuCommand(TOGGLE_NAME, toggleDebugMenu); // 如果上次是开启状态，或者用户想在未开启时也能看到子菜单项（点击时提示未开启）， // 都在这里注册一次子菜单项，确保它们始终跟在 🔧 后面 __captureRegisterChildMenusOnce(); // 恢复上次的开启状态（只影响内部标志，不改变菜单顺序） if (debugEnabled) { __captureDebugEnabled = true; } } catch { /* ignore */ } } // 立即安装拦截器（document-start 阶段就执行，不等待 DOMContentLoaded） // 确保页面初始的 API 请求也能被捕获，避免首次进入页面时提取失败 (function installInterceptorsEarly() { if (panGuangya.isHost()) { try { panGuangya.installResponseInterceptor(); } catch (e) { console.error("[光鸭秒传工具] 安装光鸭拦截器失败:", e); } } if (panXunlei.isHost()) { try { panXunlei.installTokenInterceptor(); } catch (e) { console.error("[光鸭秒传工具] 安装迅雷拦截器失败:", e); } } })(); if (document.readyState === "loading") { document.addEventListener("DOMContentLoaded", init); } else { init(); } // 🔑 把 panXunlei 暴露到 unsafeWindow，方便控制台诊断脚本调用 // 注意：仅在调试时使用，不影响正常功能 try { if (typeof unsafeWindow !== "undefined" && unsafeWindow !== window) { unsafeWindow.panXunlei = panXunlei; unsafeWindow.__guangya_helper = helper; } // 也尝试暴露到页面 window（部分管理器 unsafeWindow 不映射到 window） if (typeof window === "object" && window) { window.panXunlei = panXunlei; window.__guangya_helper = helper; } } catch (e) { console.warn("[光鸭秒传工具] 暴露 panXunlei 到页面失败:", e); } })();