bili-transcript 1.0.2 → 1.1.0

package/SKILL.md

@@ -1,21 +1,31 @@
 ---
 name: bilibili-transcript
 description: 提取 B 站视频的文字稿/字幕/文案，或拿 B 站官方的 AI 视频总结；也用于帮用户登录 B 站账号。当用户给了一个 bilibili.com 链接、BV 号、av 号（包括 b23.tv 短链），并说"把字幕扒下来""视频讲了什么""转成文字""要文字稿/文案""总结这个视频""提取台词"时使用。也适用于用户说"帮我看这个视频的内容"而没有时间自己看的情况。
+license: MIT
+compatibility: Requires Node.js 18+ and network access to bilibili.com. Bundled scripts are zero-dependency (Node built-ins only); no npm install needed.
+metadata:
+  version: "1.0.2"
+  author: dongliang
 ---
 
 # B 站视频文字稿
 
-用 `bili` 命令。已装（`npm i -g bili-transcript` 或 `npx bili-transcript`）。
+**命令一律用 `node src/cli.mjs`（路径相对本技能目录）。**
+脚本随技能一起来，零 npm 依赖，只用 Node 内置能力。若 `src/` 不在，退回 `npx -y bili-transcript`。
 
 ## 提取文字稿
 
 ```sh
-bili <BV号|av号|URL> --plain        # 最常用：连续文字，无时间戳
-bili <目标> -o out.txt              # 长视频务必写文件
-bili <目标> --json                  # 给程序解析
+node src/cli.mjs <BV号|av号|URL> --plain     # 最常用：连续文字，无时间戳
+node src/cli.mjs <目标> -o out.txt           # 长视频务必写文件
+node src/cli.mjs <目标> --json               # 给程序解析
 ```
 
-> 命令名 **`bili-transcript`** 和 **`bili`** 等价，随便用哪个。没装的话用 `npx bili-transcript`。
+**b23.tv 短链先解析**：
+
+```sh
+curl -s -o /dev/null -w '%{url_effective}' -L "https://b23.tv/XXXXXX"
+```
 
 | 选项 | 作用 |
 |---|---|
@@ -26,32 +36,36 @@ bili <目标> --json                  # 给程序解析
 | `--summary` | 附带 B 站 AI 总结（带章节时间点） |
 | `-o FILE` | 写入文件 |
 
-**b23.tv 短链先解析**：
-
-```sh
-curl -s -o /dev/null -w '%{url_effective}' -L "https://b23.tv/XXXXXX"
-```
-
 ## 凭据
 
 字幕接口强制登录。凭据查找顺序（自动，不用问用户要）：
 
 1. 环境变量 `BILI_SESSDATA`
-2. `~/.config/bili/auth.json`（`bili login` 写的位置）
-3. `/var/minis/offloads/env_cookies_bilibili*.sh`（Minis 里浏览器导出的 cookie）
+2. `~/.config/bili/auth.json`（`login` 写的位置）
+3. **本机浏览器的 cookie 库**（只读，每次现取）
+4. `/var/minis/offloads/env_cookies_bilibili*.sh`（Minis 里浏览器导出的 cookie）
+
+第 3 级覆盖 Firefox（明文，零解密）和 Chrome / Chromium / Edge / Brave / Vivaldi / Opera（AES-128-CBC + 桌面密钥环）。用户日常开着浏览器，多半这一级就命中了，**不需要扫码**。
+
+**先跑 `doctor` 看凭据来自哪**，别急着让用户扫码。只有四级全空才轮到扫码，且**扫码前必须问用户**——`bili` 在 TTY 下会自己问，非 TTY 下会打印指引。
 
 **任何时候不要打印 SESSDATA 的值**，只说"有没有"。
 
-## 登录（扫码）
+## 登录
+
+浏览器里没有 B 站登录态时：
 
 ```sh
-bili login                      # 终端画出二维码（SSH / CI 也能用）
-bili login --png /tmp/qr.png    # 额外写图片，方便手机扫
-bili login --qr-only            # 只生成二维码，存下 key
-bili login --resume             # 用存下的 key 继续轮询
-bili login --force              # 已登录时强制重登
+node src/cli.mjs login                     # 扫码；TTY 下会先问一句
+node src/cli.mjs login --from-browser      # 从浏览器导入并固化到 auth.json，不扫码
+node src/cli.mjs login --png /tmp/qr.png   # 额外写图片，方便手机扫
+node src/cli.mjs login --qr-only           # 只生成二维码，存下 key
+node src/cli.mjs login --resume            # 用存下的 key 继续轮询
+node src/cli.mjs login --force             # 已登录时强制重登
 ```
 
+`--from-browser` 是把浏览器凭据**固化**下来的场合用的（比如之后要清浏览器数据）。平时不用——查找链第 3 级会自动现取，写进去反而会让「浏览器登出了但 auth.json 还留着」这种状态变得难排查。
+
 **推荐两步走**：先 `--qr-only --png <路径>` 生成 → 把图片展示给用户 → 再 `--resume`。用户有充足时间扫，不会因轮询超时白扫。
 
 轮询间隔 2 秒，二维码约 3 分钟过期。成功后整组 5 个 cookie 存到 `~/.config/bili/auth.json`（0600）。
@@ -59,10 +73,12 @@ bili login --force              # 已登录时强制重登
 ## 出问题了先跑自检
 
 ```sh
-bili doctor
+node src/cli.mjs doctor
 ```
 
-它会分清是**接口变了**、**凭据过期了**、还是**环境有问题**。凭据失效时输出里会出现 `-101`，让用户 `bili login --force` 重登即可。
+它会分清是**接口变了**、**凭据过期了**、还是**环境有问题**。输出里的「浏览器」段会说明本机找到了哪些浏览器、凭据取自哪个。
+
+读浏览器 cookie 库需要 Node ≥ 22.5（内置 `node:sqlite`）或系统装有 `sqlite3` 命令。都不满足时这一级会自动跳过，其余功能不受影响。
 
 ## 踩过的坑（别重犯）
 
@@ -72,6 +88,18 @@ bili doctor
 4. `x/web-interface/search/type` 未登录会 HTTP 412（风控）。
 5. 字幕 CDN 链接的 `auth_key` 有时效（几小时），别存下来当永久地址。
 6. `--list` 输出每次都会变（auth_key 是时间签名），别拿它做逐字节比对。
+7. **Chromium 系 cookie 解密的三个反直觉点**（`src/browser.mjs` 已处理，改代码时别踩回去）：
+   - 密文前缀是 `v11`——这标记以前专指 Windows App-Bound，但 Linux 上仍是标准方案，别以为要特殊处理
+   - 明文**前 32 字节是 `SHA256(host_key)`**，不是 cookie 值的一部分。不去掉长度会多 32 字节
+   - 填充是 **PKCS7**。不去掉末尾会多几个字节，nav 接口会报「连不上」，很难查
+8. **读 cookie 库用 `file:...?mode=ro`，不要用 `?immutable=1`**。`immutable=1` 声称「文件不会变」于是跳过 WAL，**静默**读到过期 cookie（刚登录完拿到旧值，最难查）。
+   - **WAL 模式的库必须先复制再读**。SQLite 打开 WAL 库时要在同目录建 `-shm`(32KB) 和 `-wal`，**只读模式也照建**（官方文档承认只读 WAL 库需可写目录）。浏览器运行时这俩文件本就在，直读看不出问题；浏览器干净退出后它们被删了，我们再直读就会凭空留下两个文件——等于偷偷写了用户的浏览器目录。代码里靠读文件头第 18 字节（2 = WAL）判断，WAL 一律复制到 `mkdtemp` 再读，约 45ms。
+   - Chrome 是传统回滚日志（不是 WAL），直读无副作用，走快路径。
+9. **域名过滤不能只靠 SQL 的 `like '%bilibili%'`**，它会放过 `bilibili.com.evil.com`。取到值之后还要按标签边界判一遍，只认 `bilibili.com` / `bilibili.cn` 及其子域。
+10. **Firefox 的 profile 在 `~/.config/mozilla/`，不是 `~/.mozilla/`**（XDG 布局）。且目录名随机，要解析 `profiles.ini` 的 `Default=`。
+11. **字幕接口缺凭据时不抛错**，而是正常返回并带 `need_login_subtitle`。判断「要不要扫码」得看 `noSubtitleReason === 'need-login'`，不是 catch 异常。
+12. **`whoami()` 必须走 `getJson()`**（带凭据）才能问出登录态。手拼 headers 不带 cookie 的话永远返回 null——这个 bug 曾让「已登录」守卫失效。
+13. **临时凭据别写 `/tmp`**。二维码的 `qrcode_key` 能换到登录 cookie，谁先轮询谁拿到账号；二维码图片扫一下就能登录。`/tmp` 全局可读、默认权限 644，写在那儿等于晾给别人看。现放在 `~/.config/bili/` 下并设 0600，登录成功后删掉。
 
 ## 输出给用户时
 
@@ -83,4 +111,5 @@ bili doctor
 ## 不接受的情况
 
 - 用户明确说"不要登录""别用我账号"→ 只剩"下音频 + 外部 ASR"。如实说明，不要假装能本地跑。
-- **不要打包浏览器、不要去读系统浏览器的 cookie 库。** 扫码方案已验证可行且更轻。
+- 用户明确说"别读我的浏览器"→ 尊重，只走环境变量和 auth.json。
+- **不要打包浏览器。** 读 cookie 库是只读的：只认 bilibili 域名下的 5 个白名单字段，不落盘、不打印值、绝不写浏览器文件。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bili-transcript",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "提取 B 站视频的文字稿、字幕和 AI 总结。零依赖，扫码登录，纯命令行。",
   "type": "module",
   "bin": {

package/src/api.mjs

@@ -1,6 +1,6 @@
 // B 站接口封装 —— wbi 签名、请求、错误处理
 import { createHash } from 'node:crypto';
-import { findSessdata } from './auth.mjs';
+import { findCredentials, cookieHeader } from './auth.mjs';
 
 export const API = 'https://api.bilibili.com';
 export const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
@@ -13,8 +13,8 @@ const MIXIN_TAB = [
 
 export function headers() {
   const h = { 'User-Agent': UA, Referer: 'https://www.bilibili.com/' };
-  const { value } = findSessdata();
-  if (value) h.Cookie = 'SESSDATA=' + value;
+  const cookie = cookieHeader(findCredentials().jar);
+  if (cookie) h.Cookie = cookie;
   return h;
 }
 

package/src/auth.mjs

@@ -2,22 +2,34 @@
 import { readFileSync, writeFileSync, mkdirSync, chmodSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
+import { readBrowserCookies, WANTED } from './browser.mjs';
 
 export const AUTH_PATH = join(homedir(), '.config', 'bili', 'auth.json');
 export const COOKIE_DIR = '/var/minis/offloads';
 
-/** 按 环境变量 → auth.json → 浏览器导出文件 的顺序找 SESSDATA */
-export function findSessdata() {
+export { WANTED };
+
+/**
+ * 按 环境变量 → auth.json → 本机浏览器 → Minis 导出文件 的顺序凑齐一组 cookie。
+ *
+ * 浏览器那级是只读、每次现取的，不写进 auth.json ——
+ * auth.json 的语义是「用户显式登录的结果」，两者混起来会让人分不清
+ * 到底是浏览器登出了还是缓存过期了。
+ */
+export function findCredentials() {
   const env = (process.env.BILI_SESSDATA || '').trim();
-  if (env) return { value: env, source: 'env BILI_SESSDATA' };
+  if (env) return { jar: { SESSDATA: env }, source: 'env BILI_SESSDATA' };
 
   if (existsSync(AUTH_PATH)) {
     try {
       const c = JSON.parse(readFileSync(AUTH_PATH, 'utf8'));
-      if (c.SESSDATA) return { value: c.SESSDATA, source: AUTH_PATH };
+      if (c.SESSDATA) return { jar: c, source: AUTH_PATH };
     } catch { /* 坏了就当没有 */ }
   }
 
+  const fromBrowser = readBrowserCookies();
+  if (fromBrowser) return { jar: fromBrowser.jar, source: `浏览器 ${fromBrowser.source}` };
+
   try {
     const files = readdirSync(COOKIE_DIR)
       .filter((f) => f.startsWith('env_cookies_bilibili'))
@@ -25,11 +37,29 @@ export function findSessdata() {
       .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
     if (files.length) {
       const m = readFileSync(files[0], 'utf8').match(/^(?:export\s+)?COOKIE_SESSDATA=(.+)$/m);
-      if (m) return { value: m[1].trim().replace(/^["']|["']$/g, ''), source: files[0] };
+      if (m) {
+        return {
+          jar: { SESSDATA: m[1].trim().replace(/^["']|["']$/g, '') },
+          source: files[0],
+        };
+      }
     }
   } catch { /* 目录不存在就算了 */ }
 
-  return { value: null, source: null };
+  return { jar: null, source: null };
+}
+
+/** 只要 SESSDATA 时的薄封装（doctor、错误提示等处用） */
+export function findSessdata() {
+  const { jar, source } = findCredentials();
+  return { value: jar?.SESSDATA || null, source: jar ? source : null };
+}
+
+/** 拼成 Cookie 头。只发白名单里那几个，不把浏览器里 B 站的其他 cookie 全转发出去 */
+export function cookieHeader(jar) {
+  if (!jar) return null;
+  const parts = WANTED.filter((n) => jar[n]).map((n) => `${n}=${jar[n]}`);
+  return parts.length ? parts.join('; ') : null;
 }
 
 export function loadAuth() {

package/src/browser.mjs

@@ -0,0 +1,471 @@
+// 从本机浏览器的 cookie 库读 B 站登录态
+//
+// 纯只读：不写任何浏览器文件，也不落盘任何 cookie。
+// 只认 bilibili 域名下的 5 个白名单字段，其余一律不碰。
+//
+// 两条路：
+//   Firefox  —— 明文存在 moz_cookies.value，一条 SQL 搞定
+//   Chromium —— AES-128-CBC，密钥来自桌面密钥环
+import { execFileSync } from 'node:child_process';
+import { chmodSync, closeSync, copyFileSync, existsSync, mkdtempSync, openSync, readFileSync, readSync, rmSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { createDecipheriv, createHash, pbkdf2Sync } from 'node:crypto';
+import { createRequire } from 'node:module';
+
+const HOME = homedir();
+const XDG_CONFIG = process.env.XDG_CONFIG_HOME || join(HOME, '.config');
+
+// Node ≥ 22.5 内置；老 Node 上拿不到，届时退到 sqlite3 CLI。
+// 必须在这里同步取 —— openAndQuery() 是模块顶层函数，看不到别的函数里的局部变量。
+let DatabaseSync = null;
+try { ({ DatabaseSync } = createRequire(import.meta.url)('node:sqlite')); } catch { /* 老 Node */ }
+
+/** 只取这几个，其余 B 站 cookie 一概不读 */
+export const WANTED = ['SESSDATA', 'bili_jct', 'DedeUserID', 'DedeUserID__ckMd5', 'sid'];
+
+/** Chromium 系的 profile 目录 → 密钥环里的 product name */
+const CHROMIUM_BROWSERS = [
+  { name: 'Chrome',   dir: 'google-chrome',                product: 'chrome' },
+  { name: 'Chromium', dir: 'chromium',                     product: 'chromium' },
+  { name: 'Edge',     dir: 'microsoft-edge',               product: 'microsoft-edge' },
+  { name: 'Brave',    dir: 'BraveSoftware/Brave-Browser',  product: 'brave' },
+  { name: 'Vivaldi',  dir: 'vivaldi',                      product: 'Vivaldi' },
+  { name: 'Opera',    dir: 'opera',                        product: 'opera' },
+];
+
+// ---------------------------------------------------------------- SQLite
+
+let _backend;        // undefined=未探测, null=不可用, 否则为读取函数
+let _backendName;    // 'node:sqlite' | 'sqlite3'
+let _backendWhy = '';
+
+/**
+ * 判断库是不是 WAL 模式 —— 读文件头第 18 字节（1=传统回滚日志，2=WAL）。
+ *
+ * 为什么非要先问这个：SQLite 打开 WAL 库时必须在同目录建 `-shm`（32KB）和
+ * `-wal`，**只读模式也照建不误**，这是它的设计（官方文档明说只读 WAL 库需要
+ * 可写目录）。浏览器运行时这两个文件本来就在，直读没影响；但浏览器干净退出后
+ * 它们会被删掉，我们再直读就会凭空留下两个文件——等于偷偷写了用户的浏览器目录。
+ * 实测确认过，不是理论风险。
+ */
+function isWal(dbPath) {
+  let fd;
+  try {
+    fd = openSync(dbPath, 'r');
+    const buf = Buffer.alloc(1);
+    return readSync(fd, buf, 0, 1, 18) === 1 && buf[0] === 2;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch { /* ignore */ }
+  }
+}
+
+/**
+ * 打开一个浏览器 cookie 库并跑一条查询。
+ *
+ * 分两级，因为两个目标会打架：
+ *   1) 直接 `mode=ro` —— 快，且会带上 WAL 里的最新数据
+ *   2) 库被浏览器锁住时（报 database is locked），退而复制 db + -wal + -shm
+ *      三件套到临时目录再读
+ *
+ * WAL 库**一律**走第 2 级：直读会在浏览器目录里留下 -shm/-wal，属于副作用。
+ * 复制一次约 45ms（Firefox 1.5MB 库），且每进程只读一遍，可以接受。
+ *
+ * ⚠️ 不要用 `?immutable=1` 抄近路。它声称「文件不会变」于是跳过 WAL，
+ * 结果是**静默**读到过期数据 —— 实测用户刚登录完，immutable 拿到的是旧值，
+ * 报错还好查，静默拿错值最难查。
+ */
+function openAndQuery(dbPath, sql) {
+  const attempt = (uri) => {
+    const db = new DatabaseSync(uri, { readOnly: true });
+    try { return db.prepare(sql).all(); } finally { db.close(); }
+  };
+
+  // 非 WAL（Chrome 的 rollback journal）直读无副作用，先试这条快路
+  if (!isWal(dbPath)) {
+    try {
+      return attempt(`file:${dbPath}?mode=ro`);
+    } catch { /* 多半是被锁了，走复制 */ }
+  }
+
+  const tmp = mkdtempSync(join(tmpdir(), 'bili-ck-'));
+  try {
+    chmodSync(tmp, 0o700);
+    for (const suffix of ['', '-wal', '-shm']) {
+      const src = dbPath + suffix;
+      if (existsSync(src)) copyFileSync(src, join(tmp, basename(dbPath) + suffix));
+    }
+    return attempt(join(tmp, basename(dbPath)));
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+/** 同理，sqlite3 CLI 版 */
+function openAndQueryCli(dbPath, sql) {
+  const run = (target) => {
+    const out = execFileSync('sqlite3', [target, '-json', sql],
+                             { encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] });
+    const t = out.trim();
+    return t ? JSON.parse(t) : [];
+  };
+
+  if (!isWal(dbPath)) {
+    try {
+      return run(`file:${dbPath}?mode=ro`);
+    } catch { /* 被锁，走复制 */ }
+  }
+
+  const tmp = mkdtempSync(join(tmpdir(), 'bili-ck-'));
+  try {
+    chmodSync(tmp, 0o700);
+    for (const suffix of ['', '-wal', '-shm']) {
+      const src = dbPath + suffix;
+      if (existsSync(src)) copyFileSync(src, join(tmp, basename(dbPath) + suffix));
+    }
+    return run(join(tmp, basename(dbPath)));
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}
+
+function sqliteReader() {
+  if (_backend !== undefined) return _backend;
+
+  if (DatabaseSync) {
+    _backend = (dbPath, sql) => openAndQuery(dbPath, sql);
+    _backendName = 'node:sqlite';
+    return _backend;
+  }
+
+  try {
+    execFileSync('sqlite3', ['--version'], { stdio: 'ignore' });
+    _backend = (dbPath, sql) => openAndQueryCli(dbPath, sql);
+    _backendName = 'sqlite3';
+    return _backend;
+  } catch { /* 没装 sqlite3 */ }
+
+  _backend = null;
+  _backendName = null;
+  _backendWhy = '需要 Node ≥ 22.5（内置 node:sqlite）或系统装有 sqlite3 命令';
+  return _backend;
+}
+
+/** 给 doctor 用：当前走的哪条读库路径 */
+export function sqliteBackendName() {
+  sqliteReader();
+  return _backendName;
+}
+
+// ---------------------------------------------------------------- 浏览器探测
+
+function parseIni(text) {
+  const secs = {};
+  let cur = null;
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith(';') || line.startsWith('#')) continue;
+    const h = line.match(/^\[(.+)\]$/);
+    if (h) { cur = h[1]; secs[cur] = {}; continue; }
+    const i = line.indexOf('=');
+    if (i > 0 && cur) secs[cur][line.slice(0, i).trim()] = line.slice(i + 1).trim();
+  }
+  return secs;
+}
+
+/** Firefox 的 profile 目录名是随机的，得解析 profiles.ini 才知道用哪个 */
+function firefoxCandidates() {
+  const ini = join(XDG_CONFIG, 'mozilla', 'firefox', 'profiles.ini');
+  if (!existsSync(ini)) return [];
+
+  let secs;
+  try { secs = parseIni(readFileSync(ini, 'utf8')); } catch { return []; }
+  const base = dirname(ini);
+
+  // 统一成绝对路径再收集。[Install*] 段给的是裸目录名，[Profile*] 段给的是
+  // 可能相对的 Path —— 两种混在一起处理才不会拼出半截路径。
+  const byName = (name) => {
+    for (const [k, s] of Object.entries(secs)) {
+      if (k.startsWith('Profile') && s.Path && (s.Path === name || s.Name === name)) {
+        return s.IsRelative === '0' ? s.Path : join(base, s.Path);
+      }
+    }
+    return join(base, name);   // [Install*] 的 Default= 就是目录名
+  };
+
+  const paths = [];
+  // [Install*] 段是 Firefox 实际在用的，优先级最高
+  for (const [k, s] of Object.entries(secs)) if (k.startsWith('Install') && s.Default) paths.push(byName(s.Default));
+  for (const [k, s] of Object.entries(secs)) if (k.startsWith('Profile') && s.Default === '1' && s.Path) {
+    paths.push(s.IsRelative === '0' ? s.Path : join(base, s.Path));
+  }
+  for (const [k, s] of Object.entries(secs)) if (k.startsWith('Profile') && s.Path) {
+    paths.push(s.IsRelative === '0' ? s.Path : join(base, s.Path));
+  }
+
+  return [...new Set(paths)]
+    .map((p) => ({ profile: p.split('/').pop(), dbPath: join(p, 'cookies.sqlite') }))
+    .filter((x) => existsSync(x.dbPath));
+}
+
+/** Chromium 系：读 Local State 里的 last_used 定位实际 profile */
+function chromiumProfileDir(root) {
+  let prof = 'Default';
+  try {
+    const ls = JSON.parse(readFileSync(join(root, 'Local State'), 'utf8'));
+    if (ls.profile?.last_used) prof = ls.profile.last_used;
+  } catch { /* 读不到就用 Default */ }
+  return prof;
+}
+
+/** 列出本机所有能读的浏览器 cookie 库（不校验有没有凭据） */
+export function detectBrowsers() {
+  const out = [];
+  for (const c of firefoxCandidates()) {
+    out.push({ kind: 'firefox', name: 'Firefox', profile: c.profile, dbPath: c.dbPath });
+  }
+  for (const b of CHROMIUM_BROWSERS) {
+    const root = join(XDG_CONFIG, b.dir);
+    if (!existsSync(root)) continue;
+    const prof = chromiumProfileDir(root);
+    const dbPath = join(root, prof, 'Cookies');
+    if (existsSync(dbPath)) {
+      out.push({ kind: 'chromium', name: b.name, product: b.product, profile: prof, dbPath });
+    }
+  }
+  return out;
+}
+
+// ---------------------------------------------------------------- Chromium 解密
+
+const SALT = 'saltysalt';
+const IV = Buffer.alloc(16, 0x20);   // 16 个空格，不是 0
+const KEYRING_SCHEMA = 'chrome_libsecret_os_crypt_password_v2';
+
+function deriveKey(password, len = 16) {
+  return pbkdf2Sync(password, SALT, 1, len, 'sha1');
+}
+
+/**
+ * 解开一条 Chromium cookie 密文。解不开返回 null，**不抛异常** ——
+ * 调用方要在一堆候选密钥里逐个试，一条解不开不能掐断整轮搜索。
+ *
+ * 密文布局（v10 / v11 都是这套）：
+ *   [3 字节前缀 "v11"][AES-128-CBC 密文]
+ * 明文布局：
+ *   [32 字节 SHA256(host_key)][cookie 值][PKCS7 填充]
+ *
+ * 三个坑：前缀是 v11 但 Linux 上仍是标准方案；前 32 字节是域名哈希不是值；
+ * 填充必须去掉，否则末尾多几个字节，nav 接口会报「连不上」。
+ */
+function decryptChromium(encBuf, key) {
+  if (key.length !== 16) return null;              // aes-128-cbc 只收 16 字节密钥
+
+  const prefix = encBuf.subarray(0, 3).toString('latin1');
+  if (prefix !== 'v10' && prefix !== 'v11') return null;
+
+  try {
+    const d = createDecipheriv('aes-128-cbc', key, IV);
+    d.setAutoPadding(false);                       // 手动去填充，顺便能校验
+    const plain = Buffer.concat([d.update(encBuf.subarray(3)), d.final()]);
+
+    const pad = plain[plain.length - 1];
+    const body = pad >= 1 && pad <= 16 ? plain.subarray(0, plain.length - pad) : plain;
+    if (body.length < 32) return null;
+
+    return { hostHash: body.subarray(0, 32), value: body.subarray(32).toString('utf8') };
+  } catch {
+    return null;    // 密文截断、长度不是 16 的倍数等，都当解不开
+  }
+}
+
+/** 密钥环密码候选：先按 product 精确查，再枚举所有 Safe Storage 兜底 */
+function keyringPasswords(product) {
+  const out = [];
+  const push = (secret) => {
+    if (secret && !out.includes(secret)) out.push(secret);
+  };
+
+  // 1) 精确查 —— 快，绝大多数情况一次命中
+  try {
+    const v = execFileSync('secret-tool', ['lookup', 'application', product],
+                           { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    push(v);
+  } catch { /* 没这条，往下枚举 */ }
+
+  // 2) 枚举兜底 —— 有的浏览器 product name 和目录名对不上。
+  //    注意条目头是 `[/18]`（带斜杠），不是 `[18]`，正则漏了斜杠就只切出 1 块。
+  try {
+    const all = execFileSync('secret-tool', ['search', '--all', 'xdg:schema', KEYRING_SCHEMA],
+                             { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 1024 * 1024 });
+    for (const block of all.split(/\n(?=\[\/?\d+\])/)) {
+      const m = block.match(/^secret = (.+)$/m);
+      if (m) push(m[1].trim());
+    }
+  } catch { /* 没有密钥环 */ }
+
+  return out;
+}
+
+/** 试出能解开这个库的密钥。用 SHA256(host_key) 前缀自证，不靠猜 */
+function crackChromiumKey(product, probe) {
+  for (const secret of keyringPasswords(product)) {
+    // secret-tool 给的是 base64 文本，Chromium 就是拿这串文本当密码用；
+    // 但个别版本存的是解码后的字节，两种都试。
+    for (const pw of [Buffer.from(secret, 'utf8'), Buffer.from(secret, 'base64')]) {
+      if (!pw.length) continue;
+      // 只用 16 字节：Chromium 在 Linux 上就是 AES-128。别顺手加 32 ——
+      // aes-128-cbc 传 32 字节密钥会抛 ERR_CRYPTO_INVALID_KEYLEN。
+      const got = decryptChromium(Buffer.from(probe.ev, 'hex'), deriveKey(pw, 16));
+      if (!got) continue;
+      const want = createHash('sha256').update(probe.host_key).digest();
+      if (got.hostHash.equals(want)) return deriveKey(pw, 16);
+    }
+  }
+  return null;
+}
+
+// ---------------------------------------------------------------- 读取
+
+const NAMES_IN = WANTED.map((n) => `'${n}'`).join(',');
+
+// SQL 里的 like 只是廉价预筛，真正认不认这个域名由 isBilibiliHost() 说了算。
+// 两边的表结构不同：Firefox 只有明文的 value，Chromium 只有密文的 encrypted_value
+const FF_SQL = `select host as host_key, name, value
+                  from moz_cookies
+                 where host like '%bilibili%' and name in (${NAMES_IN})`;
+const CR_SQL = `select host_key, name, hex(encrypted_value) as ev
+                  from cookies
+                 where host_key like '%bilibili%' and name in (${NAMES_IN})`;
+
+/**
+ * 严格判定是不是 B 站自己的域名。
+ *
+ * SQL 的 `like '%bilibili%'` 会放过 `bilibili.com.evil.com` 这类域，光靠它
+ * 可能把别人的 cookie 当凭据发给 api.bilibili.com。这里按标签边界比：
+ * 只认 bilibili.com / bilibili.cn 及其子域。
+ */
+function isBilibiliHost(host) {
+  const h = String(host || '').replace(/^\./, '').toLowerCase();
+  return h === 'bilibili.com' || h.endsWith('.bilibili.com')
+      || h === 'bilibili.cn'  || h.endsWith('.bilibili.cn');
+}
+
+/** 排序用：越靠前越优先。.bilibili.com 是主域，其他子域次之 */
+function hostRank(host) {
+  const h = String(host || '').replace(/^\./, '').toLowerCase();
+  if (h === 'bilibili.com') return 0;
+  if (h.endsWith('.bilibili.com')) return 1;
+  return 2;
+}
+
+/** 域名先过一遍白名单，再按主域优先取每个字段的第一条 */
+function pickPreferred(rows, getValue) {
+  const jar = {};
+  const sorted = [...rows].sort((a, b) => hostRank(a.host_key) - hostRank(b.host_key));
+  for (const r of sorted) {
+    if (jar[r.name] || !WANTED.includes(r.name) || !isBilibiliHost(r.host_key)) continue;
+    const v = getValue(r);
+    if (v) jar[r.name] = v;
+  }
+  return jar;
+}
+
+function readFirefox(b, read) {
+  const rows = read(b.dbPath, FF_SQL);
+  // Firefox 明文，值直接取
+  return { jar: pickPreferred(rows, (r) => r.value) };
+}
+
+function readChromium(b, read) {
+  const rows = read(b.dbPath, CR_SQL);
+  if (!rows.length) return {};
+
+  // 拿一条密文当探针试密钥。优先 SESSDATA，但它要是正好损坏了，
+  // 换别的行再试 —— 否则「密钥没问题、只是这一条坏了」会被误判成「取不到密钥环」。
+  const probes = [
+    ...rows.filter((r) => r.name === 'SESSDATA' && r.ev),
+    ...rows.filter((r) => r.ev),
+  ];
+
+  let cracked = null;
+  for (const p of probes) {
+    cracked = crackChromiumKey(b.product, p);
+    if (cracked) break;
+  }
+  if (!cracked) return { needKeyring: true };
+
+  // 解出来还要拿 SHA256(host_key) 自证，解错的行当没有
+  const jar = pickPreferred(rows, (r) => {
+    if (!r.ev) return null;
+    const got = decryptChromium(Buffer.from(r.ev, 'hex'), cracked);
+    if (!got || !got.value) return null;
+    const want = createHash('sha256').update(r.host_key).digest();
+    return got.hostHash.equals(want) ? got.value : null;
+  });
+  return jar.SESSDATA ? { jar } : {};
+}
+
+let _cache;   // 一次进程内只读一遍，headers() 会被每个请求调到
+
+/** 浏览器里刚登录完要重新读：不失效缓存的话，第二次调用只会拿到登录前的旧值 */
+export function clearBrowserCache() {
+  _cache = undefined;
+}
+
+/**
+ * 主入口：扫一遍本机浏览器，第一个能拿到 SESSDATA 的就用它。
+ * 全程只读，不落盘。
+ */
+export function readBrowserCookies() {
+  if (_cache !== undefined) return _cache;
+
+  // 用户明确说别碰浏览器时，整级跳过
+  if (process.env.BILI_NO_BROWSER) { _cache = null; return null; }
+
+  const read = sqliteReader();
+  if (!read) { _cache = null; return null; }
+
+  for (const b of detectBrowsers()) {
+    let r;
+    try {
+      r = b.kind === 'firefox' ? readFirefox(b, read) : readChromium(b, read);
+    } catch { continue; }        // 单个库读坏了不该拖垮整体
+    if (r && r.jar && r.jar.SESSDATA) {
+      _cache = { jar: r.jar, source: `${b.name}（${b.profile}）` };
+      return _cache;
+    }
+  }
+
+  _cache = null;
+  return null;
+}
+
+/** 诊断用：本机浏览器状况，不含 cookie 值 */
+export function probeBrowsers() {
+  const found = detectBrowsers();
+  if (process.env.BILI_NO_BROWSER) {
+    return { found, readable: false, reason: 'BILI_NO_BROWSER 已设置，跳过', hit: null };
+  }
+  const read = sqliteReader();
+  if (!read) return { found, readable: false, reason: _backendWhy, hit: null };
+
+  const keyringMisses = [];
+  for (const b of found) {
+    try {
+      const r = b.kind === 'firefox' ? readFirefox(b, read) : readChromium(b, read);
+      if (r && r.jar && r.jar.SESSDATA) return { found, readable: true, hit: b, reason: null };
+      // 别在这里 return —— 后面还有别的浏览器，可能那个才有登录态
+      if (r && r.needKeyring) keyringMisses.push(b.name);
+    } catch { /* 继续看下一个 */ }
+  }
+  if (keyringMisses.length) {
+    return {
+      found, readable: true, hit: null,
+      reason: `${keyringMisses.join('、')}：取不到密钥环密码（缺 secret-tool 或未解锁）`,
+    };
+  }
+  return { found, readable: true, hit: null, reason: found.length ? '浏览器里没有 B 站登录态' : null };
+}

package/src/cli.mjs

@@ -7,12 +7,15 @@
 //   bili doctor                    自检
 //   bili install-skill [选项]      把 skill 装到本地 agent
 //
-import { writeFileSync, readFileSync } from 'node:fs';
+import { writeFileSync, readFileSync, mkdirSync } from 'node:fs';
+import { createInterface } from 'node:readline/promises';
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { fetchVideo, renderText } from './fetch.mjs';
 import { login } from './login.mjs';
-import { BiliError } from './api.mjs';
+import { readBrowserCookies, clearBrowserCache } from './browser.mjs';
 
 // 版本号从 package.json 读，避免写死后漂移
 const VERSION = (() => {
@@ -29,12 +32,19 @@ bili-transcript —— B 站视频文字稿提取
 用法
   bili <BV号|av号|URL> [选项]     提取文字稿
   bili fetch <目标> [选项]        同上（显式写法）
-  bili login [选项]              扫码登录
-  bili doctor                    自检：环境 / 凭据 / 接口
+  bili login [选项]              扫码登录（或 --from-browser 从浏览器导入）
+  bili doctor                    自检：环境 / 凭据 / 浏览器 / 接口
   bili install-skill [选项]      安装 agent skill
   bili --help                    看这份帮助
   bili --version                 看版本
 
+凭据从哪来（自动，按顺序找）
+  1. 环境变量 BILI_SESSDATA
+  2. ~/.config/bili/auth.json          扫码登录写的
+  3. 本机浏览器 cookie 库               只读，每次现取
+  4. /var/minis/offloads/               Minis 导出的 cookie
+  都没有才会提示你扫码。
+
 提取选项
   --plain            只出连续文字，不带时间戳（喂给 AI 用这个）
   --json             输出 JSON（给程序/agent 解析）
@@ -42,6 +52,7 @@ bili-transcript —— B 站视频文字稿提取
   --list             只列出字幕轨，不下载正文
   --summary          附带 B 站 AI 总结
   -o, --out FILE     写入文件
+  --no-login-prompt  凭据缺失时不询问，直接报错退出
 
 登录选项
   --png <路径>       额外写出二维码图片
@@ -49,12 +60,14 @@ bili-transcript —— B 站视频文字稿提取
   --resume           用上次的二维码继续轮询
   --timeout N        轮询超时秒数（默认 180）
   --force            已登录时强制重新登录
+  --from-browser     从浏览器导入凭据并固化到 auth.json（不扫码）
 
 示例
   bili BV1xx411c7mD --plain
   bili "https://b23.tv/xxxxx" --summary -o out.txt
-  bili login --png /tmp/qr.png
+  bili login --png ~/.config/bili/qr.png
   bili login --qr-only && bili login --resume
+  bili login --from-browser
 `.trim();
 
 function parseArgs(argv) {
@@ -68,6 +81,8 @@ function parseArgs(argv) {
     else if (a === '--qr-only') o.qrOnly = true;
     else if (a === '--resume') o.resume = true;
     else if (a === '--force') o.force = true;
+    else if (a === '--from-browser') o.fromBrowser = true;
+    else if (a === '--no-login-prompt') o.noLoginPrompt = true;
     else if (a === '-p' || a === '--page') o.page = parseInt(argv[++i], 10);
     else if (a === '-o' || a === '--out') o.out = argv[++i];
     else if (a === '--png') o.png = argv[++i];
@@ -84,6 +99,108 @@ function die(msg, code = 1) {
   process.exit(code);
 }
 
+// 二维码别放 /tmp：扫一下就能登录，全局可读的目录等于把凭据晾给别人看
+const QR_PNG = join(homedir(), '.config', 'bili', 'qr.png');
+
+/** 打开默认浏览器。起不来返回 false，由调用方打印 URL 兜底，不报错退出 */
+function openBrowser(url) {
+  const cmd = { linux: 'xdg-open', darwin: 'open', win32: 'start' }[process.platform];
+  if (!cmd) return Promise.resolve(false);
+  // win32 的 start 是 cmd 内建命令，必须借 cmd /c 才执行得到
+  const [bin, args] = process.platform === 'win32'
+    ? ['cmd', ['/c', 'start', '', url]]
+    : [cmd, [url]];
+  return new Promise((resolve) => {
+    const p = spawn(bin, args, { detached: true, stdio: 'ignore' });
+    p.once('spawn', () => { p.unref(); resolve(true); });
+    p.once('error', () => resolve(false));
+  });
+}
+
+/**
+ * 凭据没了时的兜底询问。只在 TTY 下问 —— 非 TTY（agent / 管道调用）里
+ * 弹菜单会把调用方卡死，那种场合打印指引让调用方自己决定。
+ */
+async function offerLogin() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY || process.env.BILI_NO_PROMPT) {
+    console.error(`浏览器里也没找到 B 站登录态。\n需要扫码登录，请运行：bili login --png ${QR_PNG}`);
+    return false;
+  }
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  // Ctrl+D 或管道提前结束会让 question 抛 AbortError —— 一律当成「用户放弃」，别甩堆栈
+  const ask = async (q) => { try { return await rl.question(q); } catch { return null; } };
+  let fromBrowser = false;
+  try {
+    // 最多问 3 次，避免手滑输错就整个流程重来
+    let choice = null;
+    for (let i = 0; i < 3 && !choice; i++) {
+      const raw = await ask(
+        '没找到可用的 B 站登录态。选一个：\n' +
+        '  1) 打开浏览器登录（登录完自动读取）\n' +
+        '  2) 显示二维码扫码登录\n' +
+        '请输入 1 或 2：'
+      );
+      if (raw === null) { console.error('\n已取消。'); return false; }
+      const a = raw.trim();
+      if (a === '1' || a === '2') choice = a;
+    }
+    if (!choice) { console.error('没有收到 1 或 2，已放弃。'); return false; }
+
+    if (choice === '1') {
+      const url = 'https://www.bilibili.com';
+      if (!(await openBrowser(url))) console.log(`没能自动打开浏览器，请手动打开：${url}`);
+      if ((await ask('在浏览器里登录 B 站，完成后按回车继续')) === null) {
+        console.error('\n已取消。'); return false;
+      }
+
+      // 必须清缓存：不清的话读到的是本次登录前的旧值，功能会静默失效
+      clearBrowserCache();
+      const got = readBrowserCookies();
+      if (got) {
+        console.log(`已从 浏览器 ${got.source} 读到登录态`);
+        fromBrowser = true;
+      } else {
+        console.log('浏览器里还是没读到 B 站登录态，改用二维码登录。');
+      }
+    }
+  } finally {
+    rl.close();
+  }
+
+  // 选了 2，或浏览器那条路没读到登录态，都落到扫码
+  if (fromBrowser) return true;
+  // 首次运行时 ~/.config/bili 可能还不存在，writePNG 不会自己建目录
+  mkdirSync(dirname(QR_PNG), { recursive: true });
+  const r = await login({ png: QR_PNG });
+  if (r?.alreadyLoggedIn) return true;
+  if (!r?.ok) { console.error('登录没成功。'); return false; }
+  return true;
+}
+
+/** 从浏览器导入并固化到 auth.json */
+async function importFromBrowser() {
+  const { readBrowserCookies } = await import('./browser.mjs');
+  const { saveAuth, AUTH_PATH, WANTED } = await import('./auth.mjs');
+
+  const got = readBrowserCookies();
+  if (!got) {
+    console.error('本机浏览器里没找到 B 站登录态。先确认浏览器里登录着 B 站，或改用 `bili login` 扫码。');
+    return 1;
+  }
+
+  const jar = {};
+  for (const n of WANTED) if (got.jar[n]) jar[n] = got.jar[n];
+  saveAuth(jar);
+
+  const { whoami } = await import('./login.mjs');
+  const who = await whoami().catch(() => null);
+  console.log(`已从 ${got.source} 导入 ${Object.keys(jar).length} 项凭据`);
+  if (who) console.log(`  账号：${who.uname}（uid ${who.mid}）`);
+  console.log(`  已写入 ${AUTH_PATH}（权限 0600）`);
+  return 0;
+}
+
 async function main() {
   const argv = process.argv.slice(2);
   if (!argv.length) { console.log(HELP); return; }
@@ -102,6 +219,7 @@ async function main() {
 
   // ---- login ----
   if (cmd === 'login') {
+    if (o.fromBrowser) process.exit(await importFromBrowser());
     try {
       const r = await login(o);
       if (r.qrOnly && o.json) console.log(JSON.stringify(r, null, 2));
@@ -131,10 +249,19 @@ async function main() {
   try {
     v = await fetchVideo(target, { page: o.page, summary: o.summary });
   } catch (e) {
-    if (e instanceof BiliError && e.code === -101) die(e.message);
     die(e.message || String(e));
   }
 
+  // 字幕接口缺凭据时不会抛错，只是返回 need-login。这时才轮到扫码兜底：
+  // 先问一声，别不打招呼就把二维码糊人脸上。
+  if (v.noSubtitleReason === 'need-login' && !o.noLoginPrompt && !o.json) {
+    if (await offerLogin()) {
+      try {
+        v = await fetchVideo(target, { page: o.page, summary: o.summary });
+      } catch (e) { die(e.message || String(e)); }
+    }
+  }
+
   let text;
   if (o.json) {
     text = JSON.stringify({

package/src/doctor.mjs

@@ -1,6 +1,7 @@
 // 自检 —— 一眼分清「接口变了」还是「该重新登录了」
 import { API, getJson, wbiQuery, headers } from './api.mjs';
 import { findSessdata, AUTH_PATH } from './auth.mjs';
+import { probeBrowsers, sqliteBackendName } from './browser.mjs';
 
 const R = { pass: 0, fail: 0, warn: 0 };
 const ok = (m) => { R.pass++; console.log(`  ✅ ${m}`); };
@@ -20,6 +21,19 @@ export async function runDoctor({ json = false } = {}) {
   if (sd) ok(`SESSDATA 长度 ${sd.length}，来自 ${source}`);
   else bad(`找不到凭据。运行 \`bili login\` 扫码登录（默认位置 ${AUTH_PATH}）`);
 
+  log('\n== 浏览器 ==');
+  const bp = probeBrowsers();
+  const backend = sqliteBackendName();
+  if (!backend) {
+    soft(`读不了浏览器 cookie 库：${bp.reason}`);
+  } else {
+    const list = bp.found.map((b) => `${b.name}（${b.profile}）`).join('、');
+    if (bp.hit) ok(`${bp.hit.name}（${bp.hit.profile}）—— 已从中取到凭据`);
+    else if (bp.reason) soft(`${bp.reason}${list ? `（找到 ${list}）` : ''}`);
+    else if (list) soft(`找到 ${list}，但没有 B 站登录态`);
+    else soft('本机没找到浏览器 cookie 库');
+  }
+
   if (sd) {
     log('\n== 凭据可用性 ==');
     const r = await getJson(`${API}/x/web-interface/nav`).catch(() => null);

package/src/fetch.mjs

@@ -99,7 +99,7 @@ export function renderText(v, { plain = false, list = false } = {}) {
   out.push(`UP: ${v.uploader} | 时长 ${v.duration}s | ${v.url}`);
 
   if (v.noSubtitleReason === 'need-login') {
-    out.push('\n[字幕接口要求登录：当前无有效凭据，拿不到字幕轨。运行 `bili login` 扫码登录]');
+    out.push('\n[字幕接口要求登录：环境变量、auth.json、浏览器 cookie 里都没找到凭据。运行 `bili login` 扫码登录]');
   } else if (v.noSubtitleReason === 'none-available') {
     out.push('\n[该视频没有字幕轨。纯音乐 / MV / CG 类视频通常没有。可加 --summary 试试 B 站的 AI 总结。]');
   }

package/src/install-skill.mjs

@@ -22,7 +22,7 @@ export async function installSkill({ global: isGlobal = true } = {}) {
 
   // 1) 首选：npx skills add（走官方生态，兼容性最好）
   log('尝试 `npx skills add` …');
-  const r = spawnSync('npx', ['-y', 'skills@latest', 'add', 'dongliang/bili-transcript',
+  const r = spawnSync('npx', ['-y', 'skills@latest', 'add', 'dongliang/skills', '--skill', 'bilibili-transcript',
                               isGlobal ? '-g' : '-p', '-y'],
                       { stdio: 'inherit', shell: process.platform === 'win32' });
   if (r.status === 0) {

package/src/login.mjs

@@ -1,12 +1,17 @@
 // 扫码登录 —— 纯命令行，不需要任何浏览器
-import { writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { writeFileSync, readFileSync, existsSync, mkdirSync, chmodSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import { encodeQR, renderText, writePNG } from './qr.mjs';
-import { UA, API } from './api.mjs';
-import { saveAuth, AUTH_PATH, findSessdata } from './auth.mjs';
+import { UA, API, getJson } from './api.mjs';
+import { saveAuth, AUTH_PATH } from './auth.mjs';
 
 const H = { 'User-Agent': UA, Referer: 'https://www.bilibili.com/' };
 const QRAPI = 'https://passport.bilibili.com/x/passport-login/web/qrcode';
-const KEYFILE = '/tmp/bili_qr.json';
+
+// 放在用户目录而不是 /tmp：这个 key 能换到登录 cookie，谁先轮询谁拿到账号。
+// /tmp 是全局可读的，写在那儿等于把凭据晾给别人看（实测默认权限 644）。
+const KEYFILE = join(homedir(), '.config', 'bili', 'qr-pending.json');
 
 /** 读 cookie 头。不同 Node 构建行为不一致：getSetCookie() 可能不存在，get() 可能返回数组 */
 function readSetCookies(resp) {
@@ -20,9 +25,10 @@ function readSetCookies(resp) {
   return raw ? [raw] : [];
 }
 
+/** 当前登录的是谁。走 getJson 才能带上凭据 —— 手拼 H 的话永远问不出登录态 */
 export async function whoami() {
-  const nav = await (await fetch(`${API}/x/web-interface/nav`, { headers: H })).json();
-  return nav.data?.isLogin ? nav.data : null;
+  const nav = await getJson(`${API}/x/web-interface/nav`).catch(() => null);
+  return nav?.data?.isLogin ? nav.data : null;
 }
 
 export async function login({ png = null, qrOnly = false, resume = false, timeout = 180, force = false, log = console.log }) {
@@ -64,7 +70,9 @@ export async function login({ png = null, qrOnly = false, resume = false, timeou
   }
 
   if (qrOnly) {
-    writeFileSync(KEYFILE, JSON.stringify({ url, key, ts: Date.now() }) + '\n');
+    mkdirSync(dirname(KEYFILE), { recursive: true });
+    writeFileSync(KEYFILE, JSON.stringify({ url, key, ts: Date.now() }) + '\n', { mode: 0o600 });
+    try { chmodSync(KEYFILE, 0o600); } catch { /* 有的文件系统不支持，忽略 */ }
     log(`已保存二维码到 ${KEYFILE}。给用户看完后用 --resume 继续轮询。`);
     return { qrOnly: true, url, key, png };
   }
@@ -103,6 +111,8 @@ export async function login({ png = null, qrOnly = false, resume = false, timeou
   if (!jar.SESSDATA) throw new Error('超时，或没能拿到凭据。请重试。');
 
   saveAuth(jar);
+  // 登录成了就把待用 key 删掉，不留在盘上
+  if (resume) try { unlinkSync(KEYFILE); } catch { /* 已经没了就算了 */ }
   const who = await whoami().catch(() => null);
 
   log('\n=== 登录成功 ===');

package/src/qr.mjs

@@ -1,4 +1,4 @@
-import { writeFileSync as _wfs } from 'node:fs';
+import { writeFileSync as _wfs, chmodSync as _chmod } from 'node:fs';
 import { deflateSync } from 'node:zlib';
 // 纯 JS 二维码编码器 —— 零依赖
 // 支持：字节模式、纠错等级 M、版本 1–10、自动选版本、掩码自动择优
@@ -379,7 +379,9 @@ export function writePNG(matrix, path, { scale = 8, quiet = 4 } = {}) {
     chunk('IDAT', deflateSync(raw, { level: 9 })),
     chunk('IEND', Buffer.alloc(0)),
   ]);
-  _wfs(path, png);
+  // 0600：这张图扫一下就能登录，不该让同机其他人读到
+  _wfs(path, png, { mode: 0o600 });
+  try { _chmod(path, 0o600); } catch { /* 有的文件系统不支持，忽略 */ }
   return { width: w, height: h, bytes: png.length };
 }