baiduwangpan-cli 1.1.0 → 1.1.1

package/README.md

@@ -42,7 +42,9 @@
 | **列出群组** | `bdp groups` | 所有群聊 + gid |
 | **群内分享库** | `bdp gshares <gid>` | 顶层分享目录 |
 | **浏览群文件** | `bdp gls <gid> <fs_id>` | 分页 + 递归 |
-| **搜索群文件** | `bdp gsearch <gid> "关键词"` | 按文件名搜索 |
+| **搜索群文件** | `bdp gsearch <gid> "关键词"` | 按文件名搜索（缓存命中秒回） |
+| 群目录树 | `bdp gtree <gid>` | BFS 构建目录树 |
+| 群缓存管理 | `bdp cache [clear]` | 查看 / 清空会话缓存 |
 
 ## 🚀 快速开始
 
@@ -52,7 +54,8 @@
 npm install -g baiduwangpan-cli
 ```
 
-安装时会**自动下载** BaiduPCS-Go 引擎（支持 GitHub 镜像加速，国内也能装）。也支持手动克隆：
+安装时会**自动下载** BaiduPCS-Go 引擎（镜像优先加速，国内也能装；全部下载源失败时打印手动下载地址，不阻断安装）。
+CLI 会自动发现引擎（包根固定路径或 `BaiduPCS-Go-v4.0.1-windows-x64/` 版本子目录），升级不会丢 `pcsPath` 配置。也支持手动克隆：
 
 ```bash
 git clone https://github.com/NkAntony777/baiduwangpan-cli.git
@@ -135,21 +138,43 @@ bdp rm <path>                    删除文件/目录
 
 ```
 bdp groups                       列出所有群组
-bdp gshares <gid>                列出群内分享库
-bdp gls <gid> <fs_id> [--page N] 浏览分享库内容
-bdp gsearch <gid> <keyword>      搜索群文件名
+bdp gshares <gid> [--no-cache]    列出群内分享库 (自动游标翻页)
+bdp gls <gid> <fs_id> [--page N] [--page-size N] [--from-uk X] [--msg-id Y]
+                                  [--parent-fs-id Z] [--no-cache]   浏览分享库内容
+bdp gtree <gid> [--depth N] [--concurrency N] [--max-nodes N]
+                                  [--max-pages N] [--max-requests N] [--no-cache]   构建群目录树
+bdp gsearch <gid> <keyword>      搜索群文件名 (全量遍历目录)
+                                  [--page N] [--limit N] [--depth N] [--concurrency N]
+                                  [--max-pages N] [--max-requests N] [--no-unique]
+                                  [--all|--all-results] [--timeout N] [--no-cache]
+bdp cache [clear]                查看 / 清空会话缓存 (~/.bdp/cache/)
 ```
 
 ### 通用选项
 
 ```
 --json                           JSON 结构化输出 (Agent 友好)
+--json-file <path>               JSON 写入文件 (UTF-8, 绕开控制台编码)
+--verbose                        进度/日志只写 stderr
 -n <N>                           行数 (head/tail, 默认 20)
 -p <path>                        搜索路径 (search, 默认 /)
 -i                               忽略大小写 (grep)
 -N                               显示行号 (cat/grep)
 -o <dir>                         输出目录 (get)
---page <N>                       页码 (gls)
+--page <N>                       页码 (gls/gsearch, 默认 1)
+--page-size <N>                  每页条数 (gls, 默认 50, 最大 100)
+--limit <N>                      每页条数 (gsearch, 默认 50)
+--depth <N>                      递归深度 (gsearch 默认 1 / gtree 默认 2)
+--concurrency <N>                并发扫描数 (gsearch/gtree, 默认 4, 1-8)
+--max-nodes <N>                  树节点上限 (gtree, 默认 2000)
+--max-pages <N>                  单目录最大页数 (gsearch/gtree, 默认 50, 100 条/页)
+--max-requests <N>               单命令请求预算 (gsearch/gtree, 默认 400, 防限流)
+--from-uk <X> / --msg-id <Y>     分享来源参数 (gls 子目录)
+--parent-fs-id <Z>               父目录 fsId (gls, errno=-3 时回退用)
+--no-unique                      保留不同 msgId 的重复项 (gsearch)
+--all, --all-results             忽略分页获取全部结果 (gsearch; 不限时, 慢但完整)
+--timeout <N>                    超时秒数，到点返回已扫到的部分结果 (gsearch; 0=不限时, 默认 0)
+--no-cache                       禁用会话缓存 (gsearch/gtree/gshares/gls)
 ```
 
 ## 🤖 Agent 集成示例
@@ -244,7 +269,7 @@ bdp groups                          bdp gshares <gid>
 
 - 群聊文件**没有服务端搜索接口**（`listshare`/`shareinfo` 的 `key`/`keyword` 参数被忽略，`/api/search` 不支持群维度）——网页端搜索同样是客户端遍历，`gsearch` 走的是同一条路。
 - `shareinfo` 每页**硬上限 100 条**（`num>100` 不返回更多），`page` 翻页可用 → `gsearch`/`gtree` 自动全页遍历，不再漏数据。
-- 高频调用会触发限流，表现为 `errno=-3`、**self-echo**（`errno=0` 但返回目录自身）、或空列表；工具自动退避重试、连续限流停止扫描，重跑命令即续扫。
+- 高频调用会触发限流，表现为 `errno=-3`、**self-echo**（`errno=0` 但返回目录自身）、或空列表；工具自动退避重试、连续限流停止扫描，重跑命令即续扫（`--max-requests` 可控制单命令请求预算，默认 400）。
 - 群文件路径可能含**非法百分号编码**（裸 `%`），直接 `decodeURIComponent` 会抛 `URIError` 报废整个目录 → 已改为安全解码。
 - `gsearch`/`gtree`/`gshares` 默认启用**磁盘会话缓存**（目录 30min / 分享 5min，`~/.bdp/cache/`，`--no-cache` 关闭、`bdp cache clear` 清理）——重复搜索秒回，深扫续扫收敛。
 
@@ -321,6 +346,7 @@ skills/baiduwangpan/
 - **下载限速**：非 SVIP 用户下载受百度限速策略限制
 - **cat 限制**：为防止误读超大文件，`cat` 默认限制 1MB，可通过 `BDP_MAX_CAT_BYTES` 环境变量调整
 - **群聊文件**：群聊 API 为逆向获取，可能随百度服务端变更而失效
+- **1.1.0 升级**：若引擎丢失（postinstall 网络失败），CLI 会自动发现 `BaiduPCS-Go-v*` 版本子目录中的二进制；config 里失效的绝对 `pcsPath` 也会自动回退到自动发现，无需手改配置
 
 ## 🤝 致谢
 

package/bin/bdp.js

@@ -82,8 +82,12 @@ function parseArgs(argv) {
       opts.flags.unique = true;
     } else if (arg === "--no-unique") {
       opts.flags.unique = false;
-    } else if (arg === "--all") {
+    } else if (arg === "--all" || arg === "--all-results") {
       opts.flags.all = true;
+    } else if (arg === "--timeout") {
+      opts.flags.timeout = parseInt(argv[++i], 10) || 0;
+    } else if (arg === "--timeout-ms") {
+      opts.flags.timeoutMs = parseInt(argv[++i], 10) || 0;
     } else if (arg === "-n" || arg === "--lines") {
       opts.flags.n = parseInt(argv[++i], 10) || 20;
     } else if (arg === "-p" || arg === "--path") {
@@ -476,13 +480,54 @@ cmds.gsearch = async (args, json) => {
     concurrency: args.flags.concurrency || 4,
     unique: args.flags.unique !== false,
     all: args.flags.all === true,
+    timeoutMs: args.flags.timeoutMs || (args.flags.timeout ? args.flags.timeout * 1000 : 0),
     depth: args.flags.depth || 1,
     maxPages: args.flags.maxPages || 50,
     maxRequests: args.flags.maxRequests || 400,
     cache: args.flags.noCache !== true,
   };
 
-  verboseLog(args, `gsearch gid=${gid} keyword="${keyword}" page=${opts.page} limit=${opts.limit} concurrency=${opts.concurrency} unique=${opts.unique} all=${opts.all} depth=${opts.depth} maxPages=${opts.maxPages} maxRequests=${opts.maxRequests} cache=${opts.cache}`);
+  // --json-file：扫描过程中持续写部分结果，即使被外部超时/杀掉，部分结果也已落盘
+  const jsonFile = args.flags.jsonFile;
+  const fsMod = require("fs");
+  let lastProgressWrite = 0;
+  if (jsonFile) {
+    fsMod.writeFileSync(jsonFile, JSON.stringify({ running: true, results: [], complete: false, partial: true }, null, 2), "utf-8");
+  }
+  opts.onProgress = (snap) => {
+    if (!jsonFile) return;
+    const now = Date.now();
+    if (snap.running && now - lastProgressWrite < 400) return; // 节流，避免频繁写盘
+    lastProgressWrite = now;
+    fsMod.writeFileSync(
+      jsonFile,
+      JSON.stringify(
+        {
+          running: snap.running,
+          results: snap.results,
+          page: snap.page,
+          pageSize: snap.pageSize,
+          complete: snap.complete,
+          partial: snap.partial,
+          timedOut: snap.timedOut,
+          stoppedReason: snap.stoppedReason,
+          scannedShares: snap.scannedShares,
+          totalShares: snap.totalShares,
+          failedShares: snap.failedShares,
+          throttledShares: snap.throttledShares,
+          cachedDirs: snap.cachedDirs,
+          budgetUsed: snap.budgetUsed,
+          depth: snap.depth,
+          maxPages: snap.maxPages,
+        },
+        null,
+        2
+      ),
+      "utf-8"
+    );
+  };
+
+  verboseLog(args, `gsearch gid=${gid} keyword="${keyword}" page=${opts.page} limit=${opts.limit} concurrency=${opts.concurrency} unique=${opts.unique} all=${opts.all} timeoutMs=${opts.timeoutMs} depth=${opts.depth} maxPages=${opts.maxPages} maxRequests=${opts.maxRequests} cache=${opts.cache}`);
   const result = await group.searchFiles(gid, keyword, opts);
 
   if (result.partial) {
@@ -508,7 +553,9 @@ cmds.gsearch = async (args, json) => {
       const dir = r.isDir ? "[DIR] " : "      ";
       console.log(`  ${dir}${r.path || r.name}  ${formatSize(r.size)}  fs_id:${r.fsId}`);
     });
-    if (result.throttled) {
+    if (result.timedOut) {
+      console.error(`⚠️  搜索超时（${Math.round(opts.timeoutMs / 1000)}s），已返回部分结果（complete:false, partial:true）。重跑或增大 --timeout / 用 --all-results 不限时`);
+    } else if (result.throttled) {
       console.error(`⚠️  API 限流中断（已扫描 ${result.scannedShares}/${result.totalShares} 分享，失败 ${result.failedShares}）。重跑命令可续扫（磁盘缓存加速）`);
     } else if (result.partial) {
       console.error(`[verbose] ${result.failedShares} shares failed (partial result)`);
@@ -590,7 +637,8 @@ GROUP CHAT OPERATIONS (群聊)
                              [--page N] [--page-size N] [--from-uk X] [--msg-id Y] [--parent-fs-id Z]
   gsearch <gid> <keyword>    Search group file names (全量遍历目录, 缓存命中秒回)
                              [--page N] [--limit N] [--depth N] [--concurrency N]
-                             [--max-pages N] [--max-requests N] [--no-unique] [--all] [--no-cache]
+                             [--max-pages N] [--max-requests N] [--no-unique]
+                             [--all|--all-results] [--timeout N] [--no-cache]
   cache [clear]              Show cache info or clear session cache
   error <code>               Explain an error code (e.g. -3)
 
@@ -620,7 +668,8 @@ OPTIONS
   --concurrency <N>           Parallel share scans for gsearch/gtree (default 4)
   --no-cache                  Disable in-process session cache (gsearch/gtree/gshares/gls)
   --no-unique                 Keep duplicates from different msgId (gsearch)
-  --all                       Fetch all results, no paging (gsearch, not Agent default)
+  --all, --all-results        Fetch all results, no paging (gsearch; slow but never truncates)
+  --timeout <N>               Abort after N seconds and return partial results (gsearch; 0=unlimited)
 
 EXAMPLES
   bdp login --bduss abc123 --stoken def456

package/lib/config.js

@@ -5,6 +5,8 @@ const os = require("os");
 const CONFIG_DIR = process.env.BDP_CONFIG_DIR || path.join(os.homedir(), ".bdp");
 const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 
+const PCS_BINARY_NAMES = ["BaiduPCS-Go.exe", "BaiduPCS-Go"];
+
 function load() {
   try {
     const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
@@ -19,6 +21,49 @@ function save(cfg) {
   fs.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
 }
 
+// 在目录内查找 BaiduPCS-Go 二进制：
+//  1) 固定路径（postinstall 目标，如 node_modules/baiduwangpan-cli/BaiduPCS-Go.exe）
+//  2) 版本子目录（如 BaiduPCS-Go-v4.0.1-windows-x64/BaiduPCS-Go.exe，
+//     postinstall 失败后手动解压的常见位置）
+function findPCSInDir(dir) {
+  if (!dir) return null;
+  for (const name of PCS_BINARY_NAMES) {
+    const p = path.join(dir, name);
+    try {
+      if (fs.existsSync(p) && fs.statSync(p).isFile()) return p;
+    } catch {}
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.includes("BaiduPCS-Go")) continue;
+    for (const name of PCS_BINARY_NAMES) {
+      const p = path.join(dir, entry.name, name);
+      try {
+        if (fs.existsSync(p) && fs.statSync(p).isFile()) return p;
+      } catch {}
+    }
+  }
+  return null;
+}
+
+function findPCS() {
+  // 1. 包根目录（postinstall 目标）：固定路径 + 版本子目录
+  const pkgRoot = path.join(__dirname, "..");
+  const found = findPCSInDir(pkgRoot);
+  if (found) return found;
+  // 2. 全局 node_modules 目录（含版本子目录）
+  const nmGlobal = path.join(__dirname, "..", "..");
+  const foundGlobal = findPCSInDir(nmGlobal);
+  if (foundGlobal) return foundGlobal;
+  // 3. Fallback to PATH
+  return "BaiduPCS-Go";
+}
+
 function get() {
   const fileCfg = load();
   return {
@@ -28,13 +73,29 @@ function get() {
     webTransport: fileCfg.webTransport || "curl",
     browserProfile: fileCfg.browserProfile || "",
     browserPort: parseInt(fileCfg.browserPort || "0", 10) || 0,
-    pcsPath: fileCfg.pcsPath || process.env.BAIDUPCS_CMD || findPCS(),
+    pcsPath: resolvePcsPath(fileCfg),
     ua: fileCfg.ua || process.env.NETDISK_UA ||
       "netdisk;P2SP;3.0.0.8;netdisk;11.12.3;ANG-AN00;android-android;10.0;JSbridge4.4.0;jointBridge;1.1.0;",
     maxBytes: parseInt(fileCfg.maxBytes || process.env.BDP_MAX_CAT_BYTES || "1048576", 10),
   };
 }
 
+// pcsPath 解析顺序：config 文件 → 环境变量 BAIDUPCS_CMD → 自动发现。
+// 兼容 1.1.0 升级丢路径问题：若 config 里存的绝对路径已失效（升级后旧包被替换），
+// 自动回退到自动发现（findPCS 会搜版本子目录），避免 search/cat/get/grep 全部报
+// "BaiduPCS-Go not found at: BaiduPCS-Go"。
+function resolvePcsPath(fileCfg) {
+  const stored = fileCfg.pcsPath || process.env.BAIDUPCS_CMD || "";
+  const auto = findPCS();
+  if (stored && path.isAbsolute(stored)) {
+    try {
+      if (fs.existsSync(stored)) return stored;
+    } catch {}
+    return auto; // 绝对路径已失效 → 自动发现
+  }
+  return stored || auto;
+}
+
 function set(key, value) {
   const cfg = load();
   cfg[key] = value;
@@ -50,26 +111,13 @@ function setAuth(values) {
   for (const key of ["bduss", "stoken", "cookie", "webTransport", "browserProfile", "browserPort"]) {
     delete cfg[key];
   }
+  // setAuth 只替换认证相关字段，保留 pcsPath/ua/maxBytes 等自定义配置（升级不丢 pcsPath）
   save({ ...cfg, ...values });
 }
 
-function findPCS() {
-  // 1. Look in package root (postinstall target)
-  const pkgRoot = path.join(__dirname, "..");
-  for (const name of ["BaiduPCS-Go.exe", "BaiduPCS-Go"]) {
-    const p = path.join(pkgRoot, name);
-    if (fs.existsSync(p)) return p;
-  }
-  // 2. Look in global node_modules
-  const nmGlobal = path.join(__dirname, "..", "..", "BaiduPCS-Go.exe");
-  if (fs.existsSync(nmGlobal)) return nmGlobal;
-  // 3. Fallback to PATH
-  return "BaiduPCS-Go";
-}
-
 function isLoggedIn() {
   const cfg = get();
   return !!(cfg.bduss && cfg.stoken);
 }
 
-module.exports = { get, set, update, setAuth, load, save, isLoggedIn, CONFIG_DIR, CONFIG_FILE };
+module.exports = { get, set, update, setAuth, load, save, isLoggedIn, findPCS, findPCSInDir, resolvePcsPath, CONFIG_DIR, CONFIG_FILE };

package/lib/group.js

@@ -525,6 +525,7 @@ async function searchFiles(gid, keyword, options = {}) {
   const maxPages = Math.min(Math.max(1, options.maxPages || 50), 200); // 单目录最多拉取页数（100/页）
   const cache = options.cache === true;
   const maxRequests = Math.min(Math.max(1, options.maxRequests || DEFAULT_MAX_REQUESTS), 2000);
+  const timeoutMs = options.timeoutMs > 0 ? options.timeoutMs : 0; // 0 = 不限时
   const budget = { remaining: maxRequests };
   const throttleState = { consecutive: 0 };
   const startIdx = (page - 1) * limit;
@@ -541,6 +542,17 @@ async function searchFiles(gid, keyword, options = {}) {
   let throttledShares = 0;
   let cachedDirs = 0;
   let finished = false;
+  let timedOut = false;
+  let stoppedReason = null;
+
+  // 超时控制：不中断当前批，批结束后停下并返回已拿到的部分结果
+  // （complete:false, partial:true）。配合 CLI --json-file 的 onProgress 持续写盘，
+  // 即使被外部超时/杀掉，部分结果也已提前落盘。
+  let timeoutTimer = null;
+  if (timeoutMs > 0) {
+    timeoutTimer = setTimeout(() => { timedOut = true; }, timeoutMs);
+    if (typeof timeoutTimer.unref === "function") timeoutTimer.unref();
+  }
 
   const pushIfMatch = (item) => {
     if (finished) return;
@@ -548,7 +560,10 @@ async function searchFiles(gid, keyword, options = {}) {
     if (unique && seen.has(key)) return;
     seen.add(key);
     results.push(item);
-    if (results.length >= stopAt) finished = true;
+    if (results.length >= stopAt) {
+      finished = true;
+      if (!stoppedReason) stoppedReason = "page-limit";
+    }
   };
 
   // 阶段 1：顶层分享名称匹配（非目录分享在此完成扫描）
@@ -580,10 +595,12 @@ async function searchFiles(gid, keyword, options = {}) {
   let queue = dirShares.map((s) => ({ fsId: s.fsId, fromUk: s.fromUk, msgId: s.msgId, depth: 1 }));
 
   for (let level = 1; level <= depth && queue.length > 0 && !finished; level++) {
+    if (timedOut) { finished = true; stoppedReason = stoppedReason || "timeout"; break; }
     const current = queue;
     queue = [];
 
     for (let i = 0; i < current.length && !finished; i += concurrency) {
+      if (timedOut) { finished = true; stoppedReason = stoppedReason || "timeout"; break; }
       const batch = current.slice(i, i + concurrency);
       const batchResults = await Promise.all(
         batch.map(async (share) => {
@@ -591,6 +608,7 @@ async function searchFiles(gid, keyword, options = {}) {
           if (budget.remaining <= 0) {
             // 请求预算耗尽：剩余目录快速失败，避免失控触发限流
             failedShares++;
+            if (!stoppedReason) stoppedReason = "budget";
             return { matches: [], subDirs: [] };
           }
           try {
@@ -628,21 +646,59 @@ async function searchFiles(gid, keyword, options = {}) {
 
       // 检测到限流后自动放慢（批间降速），缓解服务端压力
       if (throttleState.consecutive > 0) await delay(300);
+      if (timedOut) { finished = true; stoppedReason = stoppedReason || "timeout"; break; }
       // 连续限流 ≥3 次：服务端已饱和，停止扫描快速失败。
       // 已成功扫描的目录已写入磁盘缓存，重跑命令只补扫缺失部分（续扫收敛）。
       if (throttleState.consecutive >= 3) {
         if (throttledShares < 3) throttledShares = 3;
         finished = true;
+        stoppedReason = stoppedReason || "throttled";
         break;
       }
+
+      // 每批扫描完主动上报部分结果（CLI 用于持续写 --json-file）
+      if (typeof options.onProgress === "function") {
+        options.onProgress({
+          results,
+          page,
+          pageSize: limit,
+          total: null,
+          complete: false,
+          partial: true,
+          running: true,
+          timedOut: false,
+          stoppedReason,
+          scannedShares,
+          totalShares,
+          failedShares,
+          throttledShares,
+          cachedDirs,
+          budgetUsed: maxRequests - budget.remaining,
+          depth,
+          maxPages,
+        });
+      }
     }
   }
 
-  const complete = scannedShares >= totalShares;
+  if (timeoutTimer) clearTimeout(timeoutTimer);
+
+  if (timedOut) {
+    finished = true;
+    stoppedReason = stoppedReason || "timeout";
+  }
+
+  // 完整度判定：BFS 自然结束（队列清空 / 达到 depth 上限）且未被分页/限流/超时/预算中断，
+  // 且没有任何失败，才算 complete。之前"scannedShares >= totalShares"在 depth>1 或
+  // 提前截断时会误报 complete:true。
+  const scanDone = !finished && !timedOut;
+  const complete = scanDone && failedShares === 0;
   const hasMore = !fetchAll && results.length > startIdx + limit;
   const pageSlice = fetchAll ? results : results.slice(startIdx, startIdx + limit);
 
-  return {
+  if (!stoppedReason) stoppedReason = complete ? "complete" : "stopped";
+
+  const out = {
     results: pageSlice,
     page,
     pageSize: limit,
@@ -652,7 +708,9 @@ async function searchFiles(gid, keyword, options = {}) {
     nextPage: hasMore ? page + 1 : null,
     unique,
     complete,
-    partial: failedShares > 0,
+    partial: !complete,
+    timedOut,
+    stoppedReason,
     throttled: throttleState.consecutive >= 3,
     failedDirs: failedShares > 0 ? failedDirs.slice(0, 50) : [],
     scannedShares,
@@ -664,6 +722,13 @@ async function searchFiles(gid, keyword, options = {}) {
     depth,
     maxPages,
   };
+
+  // 结束态上报（running:false），CLI 据此写最终 JSON
+  if (typeof options.onProgress === "function") {
+    options.onProgress({ ...out, results, running: false });
+  }
+
+  return out;
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baiduwangpan-cli",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "百度网盘 CLI — 全盘读写 · 免下载读取文件内容 · 群聊文件浏览 (Agent 友好)",
   "main": "lib/index.js",
   "bin": {

package/scripts/postinstall.js

@@ -4,8 +4,15 @@
  * postinstall.js — 自动下载 BaiduPCS-Go 二进制
  *
  * 跨平台支持: Windows / macOS / Linux (x64, arm64, 386)
- * 下载加速:   GitHub → ghproxy 镜像 → ghfast 镜像 → 降级提示
+ * 下载加速:   镜像(ghfast/ghproxy...) 优先 → GitHub 兜底（大陆网络 GitHub 常 DNS 污染）
  * 解压方式:   Windows (PowerShell) / Unix (unzip / python3 / tar)
+ *
+ * 1.1.0 已知问题修复:
+ *  - 镜像顺序: 国内网络优先用 ghfast/ghproxy，GitHub 放最后
+ *  - download() 补 file stream error 处理：第一个镜像部分下载失败时不再直接崩溃，
+ *    确保 5 个源按顺序 fallback（此前"只跑 1 行就抛出"）
+ *  - 全部失败时打印每个源的完整下载地址，便于手动下载
+ *  - 发现版本子目录(BaiduPCS-Go-vX/)里的二进制时提升到固定路径（修复后无需手改 config）
  */
 
 const https = require("https");
@@ -19,13 +26,13 @@ const PKG_ROOT = path.join(__dirname, "..");
 const REPO = "qjfoidnh/BaiduPCS-Go";
 const VERSION = "v4.0.1";
 
-// GitHub 下载加速镜像（按优先级排列）
+// GitHub 下载加速镜像（按优先级排列）：大陆网络优先镜像，GitHub 放最后兜底
 const MIRRORS = [
-  (asset) => `https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
-  (asset) => `https://ghproxy.net/https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
   (asset) => `https://ghfast.top/https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
+  (asset) => `https://ghproxy.net/https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
   (asset) => `https://mirror.ghproxy.com/https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
   (asset) => `https://gh-proxy.com/https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
+  (asset) => `https://github.com/${REPO}/releases/download/${VERSION}/${asset}`,
 ];
 
 // ── 平台检测 ────────────────────────────────────────────
@@ -84,67 +91,69 @@ function download(url, dest, timeout = 60000) {
     const timer = setTimeout(() => {
       if (!settled) {
         settled = true;
-        file.close();
+        try { file.close(); } catch {}
         fs.unlink(dest, () => {});
         reject(new Error("timeout"));
       }
     }, timeout);
 
+    // 统一失败路径：清定时器 + 关流 + 删残留文件。file stream 的 error 也走这里，
+    // 防止第一个镜像部分下载失败后 file 抛 EPIPE/ENOSPC 未捕获导致整个 postinstall 崩溃
+    // （1.1.0 实测"只跑 1 行就抛出"，fallback 没机会执行）。
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try { file.close(); } catch {}
+      fs.unlink(dest, () => {});
+      reject(err);
+    };
+
+    file.on("error", (e) => fail(e));
+
     const req = (url, redirects = 0) => {
       if (redirects > 5) {
-        if (!settled) { settled = true; clearTimeout(timer); reject(new Error("too many redirects")); }
+        fail(new Error("too many redirects"));
         return;
       }
 
       const client = url.startsWith("https") ? https : http;
-      const r = client.get(url, { timeout: 15000 }, (res) => {
-        // 处理重定向
-        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          res.resume();
-          req(res.headers.location, redirects + 1);
-          return;
-        }
-        if (res.statusCode !== 200) {
-          res.resume();
-          if (!settled) {
-            settled = true;
-            clearTimeout(timer);
-            file.close();
-            fs.unlink(dest, () => {});
-            reject(new Error(`HTTP ${res.statusCode}`));
+      let r;
+      try {
+        r = client.get(url, { timeout: 15000 }, (res) => {
+          // 处理重定向
+          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+            res.resume();
+            req(res.headers.location, redirects + 1);
+            return;
           }
-          return;
-        }
-        res.pipe(file);
-        file.on("finish", () => {
-          file.close(() => {
-            if (!settled) {
-              settled = true;
-              clearTimeout(timer);
-              resolve();
-            }
+          if (res.statusCode !== 200) {
+            res.resume();
+            fail(new Error(`HTTP ${res.statusCode}`));
+            return;
+          }
+          res.pipe(file);
+          file.on("finish", () => {
+            file.close(() => {
+              if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolve();
+              }
+            });
           });
         });
-      });
+      } catch (e) {
+        fail(e);
+        return;
+      }
 
-      r.on("error", (e) => {
-        if (!settled) {
-          settled = true;
-          clearTimeout(timer);
-          file.close();
-          fs.unlink(dest, () => {});
-          reject(e);
-        }
-      });
+      r.on("error", (e) => fail(e));
 
       r.on("timeout", () => {
         if (!settled) {
-          settled = true;
-          clearTimeout(timer);
           r.destroy();
-          file.close();
-          fs.unlink(dest, () => {});
-          reject(new Error("connection timeout"));
+          fail(new Error("connection timeout"));
         }
       });
     };
@@ -154,20 +163,29 @@ function download(url, dest, timeout = 60000) {
 }
 
 async function downloadWithMirrors(assetName, dest) {
+  const errors = [];
   for (let i = 0; i < MIRRORS.length; i++) {
     const url = MIRRORS[i](assetName);
-    const label = i === 0 ? "GitHub" : new URL(MIRRORS[i]("x")).hostname;
+    const label = i === MIRRORS.length - 1 ? "GitHub" : new URL(MIRRORS[i]("x")).hostname;
     process.stdout.write(`  bdp: trying ${label}...`);
     try {
       await download(url, dest, 90000);
       console.log(" OK");
-      return true;
+      return { ok: true, url, label };
     } catch (e) {
-      console.log(` failed (${e.message})`);
-      if (fs.existsSync(dest)) fs.unlinkSync(dest);
+      const msg = e.message || String(e);
+      errors.push(`${label}: ${msg}`);
+      console.log(` failed (${msg})`);
+      if (fs.existsSync(dest)) {
+        try { fs.unlinkSync(dest); } catch {}
+      }
+      // GitHub DNS 污染提示
+      if (/ENOTFOUND|EAI_AGAIN|ETIMEDOUT/i.test(msg) && label === "GitHub") {
+        console.log("  bdp:   （GitHub 解析失败——大陆网络常见 DNS 污染，前面的镜像通常可用）");
+      }
     }
   }
-  return false;
+  return { ok: false, errors };
 }
 
 // ── 解压 ────────────────────────────────────────────────
@@ -213,13 +231,39 @@ function extractZip(zipPath, destDir) {
 
 // ── 主逻辑 ──────────────────────────────────────────────
 
+function findExistingBinary(binName) {
+  const binPath = path.join(PKG_ROOT, binName);
+  if (fs.existsSync(binPath)) return { path: binPath, versioned: false };
+  // 版本子目录（上次 postinstall 失败后手动解压的常见位置）
+  try {
+    for (const entry of fs.readdirSync(PKG_ROOT, { withFileTypes: true })) {
+      if (entry.isDirectory() && entry.name.includes("BaiduPCS-Go")) {
+        const p = path.join(PKG_ROOT, entry.name, binName);
+        if (fs.existsSync(p)) return { path: p, versioned: true };
+      }
+    }
+  } catch {}
+  return null;
+}
+
 async function main() {
   const binName = getBinaryName();
   const binPath = path.join(PKG_ROOT, binName);
 
-  // 已存在则跳过
-  if (fs.existsSync(binPath)) {
-    console.log("  bdp: BaiduPCS-Go already exists, skipping.");
+  // 已存在则跳过；版本子目录里的二进制提升到固定路径（CLI 固定路径优先，且不依赖版本号）
+  const existing = findExistingBinary(binName);
+  if (existing) {
+    if (existing.versioned) {
+      try {
+        fs.copyFileSync(existing.path, binPath);
+        if (os.platform() !== "win32") { try { fs.chmodSync(binPath, 0o755); } catch {} }
+        console.log(`  bdp: ✅ BaiduPCS-Go promoted from ${path.basename(path.dirname(existing.path))} to fixed path.`);
+      } catch (e) {
+        console.log(`  bdp: ⚠️  版本子目录已发现但提升失败: ${e.message}`);
+      }
+    } else {
+      console.log("  bdp: BaiduPCS-Go already exists, skipping.");
+    }
     return;
   }
 
@@ -229,14 +273,15 @@ async function main() {
   console.log("");
   console.log("  bdp: Installing BaiduPCS-Go (百度网盘 CLI 引擎)...");
 
-  // 下载
-  const ok = await downloadWithMirrors(assetName, zipPath);
-  if (!ok) {
-    console.warn("  bdp: ⚠️  All download mirrors failed.");
-    console.warn(`  bdp: Please manually download ${assetName}`);
-    console.warn(`  bdp: from https://github.com/${REPO}/releases/tag/${VERSION}`);
-    console.warn(`  bdp: and extract ${binName} to: ${PKG_ROOT}`);
-    console.warn("  bdp: (the package still works if BaiduPCS-Go is in your PATH)");
+  // 下载（镜像优先 → GitHub 兜底）
+  const result = await downloadWithMirrors(assetName, zipPath);
+  if (!result.ok) {
+    console.warn("  bdp: ⚠️  所有下载源失败（大陆网络常见：GitHub DNS 污染 / 镜像暂时抽风）。");
+    console.warn(`  bdp: 请手动下载 ${assetName}（任一地址均可）:`);
+    for (const m of MIRRORS) console.warn(`  bdp:   ${m(assetName)}`);
+    console.warn(`  bdp: 解压后把 ${binName} 放到: ${PKG_ROOT}`);
+    console.warn("  bdp:   （或版本子目录，如 BaiduPCS-Go-v4.0.1-windows-x64/，CLI 会自动发现）");
+    console.warn("  bdp: 也可直接确保 BaiduPCS-Go 在 PATH 中（包仍可正常使用）。");
     console.warn("");
     process.exit(0); // 不阻断 npm install
   }
@@ -244,7 +289,7 @@ async function main() {
   // 解压
   console.log("  bdp: Extracting...");
   if (!extractZip(zipPath, PKG_ROOT)) {
-    console.warn(`  bdp: ⚠️  Cannot extract. Please manually unzip: ${zipPath}`);
+    console.warn(`  bdp: ⚠️  解压失败。请手动解压: ${zipPath}`);
     process.exit(0);
   }
 
@@ -273,8 +318,8 @@ async function main() {
     }
     console.log(`  bdp: ✅ BaiduPCS-Go installed.`);
   } else {
-    console.warn("  bdp: ⚠️  Binary not found after extraction.");
-    console.warn(`  bdp: Please manually extract and place ${binName} in: ${PKG_ROOT}`);
+    console.warn("  bdp: ⚠️  解压后未找到二进制。");
+    console.warn(`  bdp: 请手动解压并把 ${binName} 放到: ${PKG_ROOT}`);
   }
 
   // 清理 zip 和解压目录