baiduwangpan-cli 1.0.2 → 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 集成示例
@@ -229,18 +254,25 @@ bdp groups                          bdp gshares <gid>
     │                                   │
     ├── /mbox/group/list                ├── /mbox/group/listshare
     │   → 获取全部群组 (gid)             │   → 获取分享库 (msg_id + from_uk + fs_id)
-    │                                   │
+    │                                   │       └ has_more=1 时按 last_msg_time 游标翻页
     └───────────────────────────────────┘
                 ↓
-        bdp gls <gid> <fs_id>
-                │
-                ├── /mbox/msg/shareinfo
-                │   → 浏览文件/子目录 (分页)
-                │   → 递归遍历目录树
-                ↓
-            文件列表 (名称/大小/类型/fs_id)
+        bdp gls <gid> <fs_id>       bdp gsearch <gid> "关键词"
+                │                        │
+                ├── /mbox/msg/shareinfo  ├── 全量遍历: shareinfo 自动翻页 (每页上限 100)
+                │   → 浏览文件/子目录     │   → 目录级并发扫描 + 磁盘缓存
+                ↓                        ↓
+            文件列表 (名称/大小/类型/fs_id)    匹配结果
 ```
 
+**逆向实测结论（2026-08）**：
+
+- 群聊文件**没有服务端搜索接口**（`listshare`/`shareinfo` 的 `key`/`keyword` 参数被忽略，`/api/search` 不支持群维度）——网页端搜索同样是客户端遍历，`gsearch` 走的是同一条路。
+- `shareinfo` 每页**硬上限 100 条**（`num>100` 不返回更多），`page` 翻页可用 → `gsearch`/`gtree` 自动全页遍历，不再漏数据。
+- 高频调用会触发限流，表现为 `errno=-3`、**self-echo**（`errno=0` 但返回目录自身）、或空列表；工具自动退避重试、连续限流停止扫描，重跑命令即续扫（`--max-requests` 可控制单命令请求预算，默认 400）。
+- 群文件路径可能含**非法百分号编码**（裸 `%`），直接 `decodeURIComponent` 会抛 `URIError` 报废整个目录 → 已改为安全解码。
+- `gsearch`/`gtree`/`gshares` 默认启用**磁盘会话缓存**（目录 30min / 分享 5min，`~/.bdp/cache/`，`--no-cache` 关闭、`bdp cache clear` 清理）——重复搜索秒回，深扫续扫收敛。
+
 ## 📁 项目结构
 
 ```
@@ -314,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") {
@@ -112,6 +116,12 @@ function parseArgs(argv) {
       opts.flags.depth = parseInt(argv[++i], 10) || 2;
     } else if (arg === "--max-nodes") {
       opts.flags.maxNodes = parseInt(argv[++i], 10) || 2000;
+    } else if (arg === "--max-pages") {
+      opts.flags.maxPages = parseInt(argv[++i], 10) || 50;
+    } else if (arg === "--max-requests") {
+      opts.flags.maxRequests = parseInt(argv[++i], 10) || 400;
+    } else if (arg === "--no-cache") {
+      opts.flags.noCache = true;
     } else if (arg === "--from-uk") {
       opts.flags.fromUk = argv[++i];
     } else if (arg === "--msg-id") {
@@ -379,7 +389,7 @@ cmds.groups = async (args, json) => {
 cmds.gshares = async (args, json) => {
   const gid = args._[0];
   if (!gid) { console.error("Usage: bdp gshares <gid>"); process.exit(1); }
-  const shares = await group.listShares(gid);
+  const shares = await group.listShares(gid, { cache: args.flags.noCache !== true });
   output(shares, json, (list) => {
     console.log(`${list.length} shares in group ${gid}:\n`);
     list.forEach((s, i) => {
@@ -397,6 +407,7 @@ cmds.gls = async (args, json) => {
   const opts = {
     page: args.flags.page || 1,
     pageSize: args.flags.pageSize || 50,
+    cache: args.flags.noCache !== true,
   };
   if (args.flags.fromUk) opts.fromUk = args.flags.fromUk;
   if (args.flags.msgId) opts.msgId = args.flags.msgId;
@@ -410,6 +421,10 @@ cmds.gls = async (args, json) => {
     return;
   }
 
+  if (result.autoResolved) {
+    console.error(`[auto] 传入的 fromUk/msgId 与群 ${gid} 不匹配（API errno=2131），已自动改用 gshares 解析的参数 (fromUk=${result.fromUk}, msgId=${result.msgId})`);
+  }
+
   if (result.fallback) {
     verboseLog(args, `fallback: ${result.fallback.reason} -> ${result.fallback.resolvedFsId} (${result.fallback.level})`);
   }
@@ -436,8 +451,11 @@ cmds.gtree = async (args, json) => {
     depth: args.flags.depth || 2,
     concurrency: args.flags.concurrency || 4,
     maxNodes: args.flags.maxNodes || 2000,
+    maxPages: args.flags.maxPages || 50,
+    maxRequests: args.flags.maxRequests || 400,
+    cache: args.flags.noCache !== true,
   };
-  verboseLog(args, `gtree gid=${gid} depth=${opts.depth} concurrency=${opts.concurrency} maxNodes=${opts.maxNodes}`);
+  verboseLog(args, `gtree gid=${gid} depth=${opts.depth} concurrency=${opts.concurrency} maxNodes=${opts.maxNodes} maxPages=${opts.maxPages} maxRequests=${opts.maxRequests} cache=${opts.cache}`);
   const result = await group.treeFiles(gid, opts);
 
   if (args.flags.jsonFile || json) {
@@ -462,14 +480,64 @@ 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}`);
+  // --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) {
     verboseLog(args, `partial: ${result.failedShares}/${result.totalShares} shares failed`);
+    if (result.failedDirs && result.failedDirs.length > 0) {
+      verboseLog(args, `failed dirs: ${result.failedDirs.map((f) => `${f.name || f.fsId}(${f.errno})`).slice(0, 10).join(", ")}`);
+    }
+  }
+  if (result.throttled) {
+    verboseLog(args, `throttled: API 限流中断，重跑命令可续扫（磁盘缓存只补缺失目录）`);
   }
 
   if (args.flags.legacyJson) {
@@ -485,19 +553,52 @@ 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.partial) {
+    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)`);
     }
   }
 };
 
+cmds.cache = async (args, json) => {
+  const action = args._[0] || "info";
+  const { clearGroupCache } = group;
+  if (action === "clear") {
+    clearGroupCache();
+    output({ cleared: true }, json, () => console.log("✅ 群聊会话缓存已清除"));
+    return;
+  }
+  // info: 显示缓存目录位置
+  const path = require("path");
+  const os = require("os");
+  const dir = process.env.BDP_CACHE_DIR || path.join(os.homedir(), ".bdp", "cache");
+  output({ cacheDir: dir, ttl: { dir: "30min", shares: "5min" } }, json, () => {
+    console.log(`Cache dir:  ${dir}`);
+    console.log(`Dir TTL:    30 min (gsearch/gtree 目录列表)`);
+    console.log(`Shares TTL: 5 min (gshares 分享列表)`);
+    console.log(`Clear with: bdp cache clear`);
+  });
+};
+
 cmds.error = async (args, json) => {
   const code = args._[0] || "-3";
   const ERRORS = {
-    "-3": "群分享 API 拒绝请求。已观察到大目录、错误的 msgId/fromUk、过期分享都可能触发。\n" +
-          "处理：减小 --page-size（自动重试 50→20→10），或携带 gsearch 返回的 fromUk/msgId/parentFsId 信息重试；\n" +
+    "-3": "群分享 API 拒绝请求。已观察到大目录、错误的 msgId/fromUk、过期分享、请求过于频繁(限流)都可能触发。\n" +
+          "处理：减小 --page-size（自动重试 50→20→10）或 --concurrency；\n" +
+          "      限流表现为 errno=0 但只返回目录自身（self-echo），工具会自动退避重试(1s/2s)；\n" +
+          "      大目录已支持自动全页遍历（每页上限 100，--max-pages 控制页数）；\n" +
           "      若回退到父目录（fallback level=parent），Agent 应从父目录换路径继续遍历。",
     "-6": "接口鉴权失败。通常为 access_token/cookie 失效，请重新执行 bdp login。",
+    "2131": "群分享 msg_id 不属于该群（shareinfo 以 msg_id 为查找键，from_uk 不参与校验）。\n" +
+            "常见原因：gid 与 --from-uk/--msg-id/--parent-fs-id 来自不同群/分享库（参数错配）。\n" +
+            "处理：用 bdp gshares <gid> 查看本群分享（或 bdp gsearch <gid> <关键词>），\n" +
+            "      取其中一行的 fsId/fromUk/msgId 重试，保证 gid/fsId/fromUk/msgId 同源；\n" +
+            "      fsId 为子目录时保持其父分享行的 fromUk/msgId 不变；\n" +
+            "      或去掉 --from-uk/--msg-id 让 CLI 自动解析（仅顶层分享）。\n" +
+            "      工具已支持：显式参数错配时自动按 fsId 纠正（结果含 autoResolved:true）。",
   };
   const msg = ERRORS[code] || `未知错误码 ${code}，请提交 Issue: https://github.com/NkAntony777/baiduwangpan-cli/issues`;
   if (args.flags.jsonFile || json) {
@@ -534,8 +635,11 @@ GROUP CHAT OPERATIONS (群聊)
                              [--depth N] [--concurrency N] [--max-nodes N]
   gls <gid> <fs_id>          Browse files in a share
                              [--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] [--no-unique] [--all]
+  gsearch <gid> <keyword>    Search group file names (全量遍历目录, 缓存命中秒回)
+                             [--page N] [--limit N] [--depth N] [--concurrency N]
+                             [--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)
 
 CONFIGURATION
@@ -559,9 +663,13 @@ OPTIONS
   --limit <N>                 Page size for gsearch (default 50)
   --depth <N>                 Recursive search/tree depth (gsearch default 1, gtree default 2)
   --max-nodes <N>             Tree node cap (gtree default 2000)
+  --max-pages <N>             Max pages per directory scan (gsearch/gtree default 50, 100 items/page)
+  --max-requests <N>          Request budget per command (gsearch/gtree default 400, prevents throttle)
   --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
@@ -594,7 +702,7 @@ async function main() {
     await handler(args, json);
   } catch (e) {
     if (json) {
-      console.log(JSON.stringify({ error: e.message }));
+      console.log(JSON.stringify({ error: e.message, ...(e.errno !== undefined ? { errno: e.errno } : {}) }));
     } else {
       console.error(`[ERROR] ${e.message}`);
     }

package/lib/browser-login.js

@@ -281,15 +281,10 @@ async function getBrowserSession(settings = {}) {
 
 async function browserJson(url, options = {}, settings = {}) {
   const session = await getBrowserSession(settings);
-  let response;
-  try {
-    response = await evaluateFetch(session.cdp, url, options);
-  } catch (error) {
-    session.cdp.close();
-    activeSession = null;
-    throw error;
-  }
+  const response = await evaluateFetch(session.cdp, url, options);
 
+  // 注意：fetch 错误（网络/API 断连）不关闭共享会话——并发批处理中一个请求失败会
+  // 连带杀死同批其他在途请求（ws 关闭）。会话死活由下次调用前的 ping 自动检测重连。
   try {
     return JSON.parse(response.text.replace(/^\s+/, ""));
   } catch {
@@ -384,8 +379,8 @@ async function browserLogin({
 
 function scheduleDisconnect() {
   if (disconnectTimer) clearTimeout(disconnectTimer);
-  // 空闲 30 秒后断开浏览器会话（批处理请求间隔通常 <30s）
-  disconnectTimer = setTimeout(disconnectBrowserSession, 30000);
+  // 空闲 90 秒后断开浏览器会话（并发批处理扫描中请求间隔可能较长，短超时会中途断连）
+  disconnectTimer = setTimeout(disconnectBrowserSession, 90000);
   disconnectTimer.unref();
 }
 

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 };