koishi-plugin-kkk 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # 更新日志
 
+## 3.6.0
+
+> 下载稳定性：**大文件不会再被 60 秒总超时掐死**，坏掉的 B站 PCDN 直链会自动换镜像。
+
+### 下载：超时改成「空闲超时」，坏源自动换源
+
+用户实测：解析一个 279.9 MB 的 B站视频时进度卡在 `0.0 MB/s`，
+日志报 `下载失败: 连接被重置 (ECONNRESET): aborted`，三次重试全部如此。
+
+查下来是两件事叠在一起：
+
+- **直链落在 PCDN 节点上**：`xy120x240x109x22xy.mcdn.bilivideo.cn:8082` 这类
+  `*.mcdn.bilivideo.cn` 边缘节点 TCP 连得上、响应头也正常，就是 60 秒只吐 118 KB；
+  而旧代码只用 `dash.video[0].base_url`，`backup_url` 里的 `upos-*` 镜像一个都没用上。
+- **下载器是「总时长 60 秒」的超时**：定时器从请求开始算、全程不重置，于是任何需要
+  超过 60 秒的文件（按 1.5 MB/s 算就是 90 MB 以上）**永远下不完**。到点被自己 `abort`
+  之后，Node 把这件事报成 `Error: aborted`（code `ECONNRESET`），日志里就成了
+  「连接被重置」—— 把「服务器风控」这条错路指给了所有人。
+
+现在的行为：
+
+- 超时是**空闲超时**：每收到一块数据就重新计时，只有真的没数据才算超时；
+  另有 30 分钟的单次尝试兜底，涓流源不会挂着跑一整天。
+- 有备用地址时，**热身 20 秒后速度仍低于 64 KB/s 就直接换源**（已经传了几 MB 再断的除外，
+  那种留着进度续传更划算）；B站视频 / 音频 / 推送解析都会带上 `backup_url` 镜像，
+  且非 PCDN 的地址排在前面。
+- 自己掐断的（空闲超时 / 换源）**不再伪装成 ECONNRESET**：日志写「下载中断: 下载超时
+  （60 秒内没有收到新数据）」，也不会再误触发「服务器断流自动降速」、建议你降 maxSpeed。
+- 进度条速度改成**按两次回调之间的增量**计算（以前是累计字节 ÷ 从第一次尝试起的总耗时，
+  断点续传时分子还会被重置），不会再出现「明明在跑却显示 `0.0 MB/s 剩余: 661min`」。
+
+新增冒烟测试 `scripts/smoke-download-source-fallback.cjs`：本地起「坏源 / 涓流源 / 健康慢源」
+三种服务，验证换源、错误文案，以及「总耗时远超 timeout 的健康下载」都能跑通。
+
 ## 3.5.0
 
 > 这一版三件事：**B站互动视频能玩了**（能一路选剧情、还能出剧情图）、**合并转发里能单独控制流程图**，

package/lib/build-metadata.json

@@ -1,7 +1,7 @@
 {
-  "version": "3.5.0",
-  "buildTime": "2026-09-24T04:07:48.461Z",
-  "buildTimestamp": 1790222868462,
+  "version": "3.6.0",
+  "buildTime": "2026-09-25T02:51:07.813Z",
+  "buildTimestamp": 1790304667814,
   "name": "koishi-plugin-kkk",
   "description": "抖音 / B站 / 快手 / 小红书 视频解析与动态推送，带 QQ 交互面板与弹幕烧录（karin-plugin-kkk 的 Koishi 移植版）",
   "homepage": "https://github.com/maimai993/koishi-plugin-kkk#readme",

package/lib/karin/module/utils/Base.js

@@ -444,15 +444,25 @@ const downloadFile = async (videoUrl, opt) => {
         autoReduceRatio: uploadConfig.downloadAutoReduce ? 0.6 : 1, // 降速比例
         minSpeed: (uploadConfig.downloadMinSpeed ?? 1) * 1024 * 1024 // MB/s -> bytes/s
     };
+    /**
+     * 速度采样点。速度必须按「两次回调之间的增量」算，不能按「累计字节 ÷ 总耗时」：
+     * 后者把重试的退避等待也算进分母，断点续传时分子还会被重置回续传点，
+     * 于是明明在正常下载也会显示成 `0.0 MB/s 剩余: 661min`（用户实测反馈）。
+     */
+    let lastSampleBytes = 0;
+    let lastSampleAt = startTime;
+    /** 平滑后的速度（byte/s） */
+    let smoothSpeed = 0;
     try {
         // 使用 networks 类进行文件下载，并通过回调函数实时更新下载进度
         const { filepath, totalBytes } = await new utils_1.Networks({
             url: videoUrl,
             headers: opt.headers ?? utils_1.baseHeaders,
             filepath: opt.filepath ?? utils_1.Common.tempDri.video + opt.title,
-            timeout: 60000, // 增加超时时间
+            timeout: 60000, // 空闲超时（连续 60s 没有新数据才算超时），传输途中会不断续期
             maxRetries: 3, // 增加重试次数
-            throttle: throttleConfig
+            throttle: throttleConfig,
+            backupUrls: opt.backupUrls
         }).downloadStream((downloadedBytes, totalBytes) => {
             // 定义进度条长度及生成进度条字符串的函数
             const barLength = 45;
@@ -467,14 +477,26 @@ const downloadFile = async (videoUrl, opt) => {
             // 计算动态 RGB 颜色
             const red = Math.floor(255 - (255 * progressPercentage) / 100); // 红色分量随进度减少
             const coloredPercentage = node_karin_1.logger.chalk.rgb(red, 255, 0)(`${progressPercentage.toFixed(1)}%`);
-            // 计算下载速度（MB/s）
-            const elapsedTime = (Date.now() - startTime) / 1000;
-            const speed = downloadedBytes / elapsedTime;
+            // 计算下载速度（MB/s）：增量法 + 一点平滑，避免数字乱跳
+            const sampleAt = Date.now();
+            const elapsedSinceSample = (sampleAt - lastSampleAt) / 1000;
+            if (elapsedSinceSample >= 0.2) {
+                // 断点续传时 downloadedBytes 会往回退，增量按 0 处理
+                const instant = Math.max(0, downloadedBytes - lastSampleBytes) / elapsedSinceSample;
+                smoothSpeed = smoothSpeed > 0 ? smoothSpeed * 0.6 + instant * 0.4 : instant;
+                lastSampleBytes = downloadedBytes;
+                lastSampleAt = sampleAt;
+            }
+            const speed = smoothSpeed;
             const formattedSpeed = (speed / 1048576).toFixed(1) + ' MB/s';
-            // 计算剩余时间
+            // 计算剩余时间（速度还没出来时不瞎猜）
             const remainingBytes = totalBytes - downloadedBytes; // 剩余字节数
-            const remainingTime = remainingBytes / speed; // 剩余时间（秒）
-            const formattedRemainingTime = remainingTime > 60 ? `${Math.floor(remainingTime / 60)}min ${Math.floor(remainingTime % 60)}s` : `${remainingTime.toFixed(0)}s`;
+            const remainingTime = speed > 1024 ? remainingBytes / speed : Number.POSITIVE_INFINITY;
+            const formattedRemainingTime = !Number.isFinite(remainingTime)
+                ? '--'
+                : remainingTime > 60
+                    ? `${Math.floor(remainingTime / 60)}min ${Math.floor(remainingTime % 60)}s`
+                    : `${remainingTime.toFixed(0)}s`;
             // 计算已下载和总下载的文件大小（MB）
             const downloadedSizeMB = (downloadedBytes / 1048576).toFixed(1);
             const totalSizeMB = (totalBytes / 1048576).toFixed(1);

package/lib/karin/module/utils/Network/Downloader.js

@@ -147,9 +147,40 @@ function listActiveDownloads() {
     }
     return result.sort((left, right) => right.at - left.at);
 }
+/* ------------------------------------------------------------------ *
+ * 坏源判定阈值
+ * ------------------------------------------------------------------ */
+/**
+ * 换源前的热身时间：新源先给这么久证明自己。
+ *
+ * B站 playurl 经常把直链指向 `*.mcdn.bilivideo.cn` 这类 PCDN 边缘节点：
+ * TCP 连得上、响应头也回得来（content-length 都正常），就是几乎不吐数据
+ * （实测 118 KB / 60 秒 ≈ 2 KB/s）。在这种源上干等毫无意义。
+ */
+const STALL_WARMUP_MS = 20_000;
+/** 热身期过后速度仍低于这个值（byte/s）且还有备用地址时，判定为坏源并换源 */
+const STALL_MIN_SPEED = 64 * 1024;
+/**
+ * 重试同一个源之前，本轮至少要传这么多字节，才值得原地重试。
+ *
+ * 传了几 MB 再断，说明源本身是好的（只是被掐了），留着进度续传最划算；
+ * 传了几百 KB 就断，那就是坏源，直接换。
+ */
+const SWITCH_IF_UNDER_BYTES = 4 * 1024 * 1024;
+/** 单次尝试的硬上限：既没数据、又没有备用源可换的「涓流」源不能永远挂着 */
+const MAX_ATTEMPT_MS = 30 * 60_000;
+/** 打个码的地址（只留 host，别把带签名的完整直链写进日志） */
+const safeHost = (url) => {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return '(非法地址)';
+    }
+};
 /**
  * 文件下载器
- * 支持断点续传、限速下载、自动重试
+ * 支持断点续传、限速下载、自动重试，以及**坏源自动换源**
  */
 class Downloader {
     axiosInstance;
@@ -161,7 +192,20 @@ class Downloader {
     throttleConfig;
     currentSpeed;
     consecutiveResets;
-    constructor(axiosInstance, url, filepath, headers, timeout, maxRetries, throttleConfig) {
+    /** 备用直链：当前源被判定为坏源时按顺序换过去（B站 dash 的 backup_url） */
+    backupUrls;
+    /**
+     * 本次尝试「被自己掐断」的原因：
+     * - `timeout`：空闲超时（连续 timeout 毫秒没收到数据）
+     * - `slow`：坏源看门狗主动放弃
+     *
+     * 自己掐断的必须和「服务器重置」区分开 —— Node 把 abort 报成
+     * `Error: aborted`（code ECONNRESET），照抄进日志会把排查方向带偏。
+     */
+    abortReason = null;
+    /** 已经换过几次源（仅用于日志） */
+    sourceSwitches = 0;
+    constructor(axiosInstance, url, filepath, headers, timeout, maxRetries, throttleConfig, backupUrls = []) {
         this.axiosInstance = axiosInstance;
         this.url = url;
         this.filepath = filepath;
@@ -171,6 +215,7 @@ class Downloader {
         this.throttleConfig = { ...types_1.DEFAULT_THROTTLE_CONFIG, ...throttleConfig };
         this.currentSpeed = this.throttleConfig.maxSpeed;
         this.consecutiveResets = 0;
+        this.backupUrls = [...backupUrls];
     }
     /**
      * 执行下载
@@ -186,11 +231,51 @@ class Downloader {
         if (!this.filepath) {
             throw new Error('未指定文件保存路径: filepath 为空');
         }
+        // 每次尝试都从「没被掐断」开始
+        this.abortReason = null;
         const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
         let intervalId = null;
         let throttleStream = null;
         let writer = null;
+        /** 本轮尝试收到的字节数（用于坏源判定，断点续传时只算这一轮新增的） */
+        let attemptBytes = 0;
+        /** 本轮尝试的开始时间 */
+        const attemptStart = Date.now();
+        let timeoutId = null;
+        let attemptCapId = null;
+        const clearTimers = () => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (attemptCapId)
+                clearTimeout(attemptCapId);
+            timeoutId = null;
+            attemptCapId = null;
+        };
+        /**
+         * 重新计时：**这是空闲超时，不是总时长超时**。
+         *
+         * 以前这里是一个从头开始算的定时器（`setTimeout(abort, 60000)` 并且全程不再重置），
+         * 于是任何需要超过 60 秒的文件（按 1.5 MB/s 算就是 90 MB 以上）都**永远下不完**：
+         * 到点就被 abort，而 Node 把「自己 abort」报成 `Error: aborted`（code ECONNRESET），
+         * 日志里就成了「下载失败: 连接被重置 (ECONNRESET): aborted」，把所有排查方向都带偏。
+         * 现在每收到一块数据就重新计时，只有**真的没数据**才超时。
+         */
+        const armIdleTimeout = () => {
+            if (this.timeout <= 0)
+                return;
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            timeoutId = setTimeout(() => {
+                this.abortReason = 'timeout';
+                controller.abort();
+            }, this.timeout);
+        };
+        armIdleTimeout();
+        // 兜底：涓流源（一直有数据但慢得离谱、又没有备用源）不能在这一次尝试里挂几个小时
+        attemptCapId = setTimeout(() => {
+            this.abortReason = 'timeout';
+            controller.abort();
+        }, MAX_ATTEMPT_MS);
         try {
             // 检查断点续传
             let startByte = 0;
@@ -234,7 +319,7 @@ class Downloader {
                 currentSpeed: this.throttleConfig.enabled ? (0, helpers_1.formatBytes)(this.currentSpeed) + '/s' : '不限速'
             });
             const response = await this.axiosInstance(requestConfig);
-            clearTimeout(timeoutId);
+            // 注意：这里**不**清除定时器 —— 传输阶段的空闲超时还得靠它（每收到数据会重新计时）
             // 检查 HTTP 状态码
             // 416 Range Not Satisfiable
             if (response.status === 416) {
@@ -328,11 +413,35 @@ class Downloader {
                 reportDownloadProgress(this.filepath, downloadedBytes, totalBytes);
             };
             const interval = totalBytes > 0 && totalBytes < 10 * 1024 * 1024 ? 1000 : 500;
-            intervalId = setInterval(printProgress, interval);
+            /**
+             * 坏源看门狗：有备用地址时，热身期过了速度还低得离谱就直接放弃这个源。
+             *
+             * 没有备用地址时不介入 —— 慢总比失败强，真正的死源交给空闲超时兜底。
+             */
+            const checkStall = () => {
+                if (this.backupUrls.length === 0)
+                    return;
+                const elapsed = Date.now() - attemptStart;
+                if (elapsed < STALL_WARMUP_MS)
+                    return;
+                const speed = attemptBytes / (elapsed / 1000);
+                if (speed >= STALL_MIN_SPEED)
+                    return;
+                node_karin_1.logger.warn(`当前下载源速度过低 (${(0, helpers_1.formatBytes)(Math.round(speed))}/s)，准备切换备用地址`);
+                this.abortReason = 'slow';
+                controller.abort();
+            };
+            intervalId = setInterval(() => {
+                printProgress();
+                checkStall();
+            }, interval);
             // 创建计数流
             const counterStream = new node_stream_1.Transform({
                 transform(chunk, encoding, callback) {
                     downloadedBytes += chunk.length;
+                    attemptBytes += chunk.length;
+                    // 还有数据在流，说明这个源活着：把空闲超时往后推
+                    armIdleTimeout();
                     callback(null, chunk);
                 }
             });
@@ -345,8 +454,6 @@ class Downloader {
             else {
                 await (0, promises_1.pipeline)(response.data, counterStream, writer);
             }
-            if (intervalId)
-                clearInterval(intervalId);
             // pipeline 已经等待所有流完成，包括 writer 的 finish 事件
             node_karin_1.logger.debug('文件下载并写入完成');
             // 验证文件大小
@@ -388,20 +495,34 @@ class Downloader {
             };
         }
         catch (error) {
-            clearTimeout(timeoutId);
+            clearTimers();
             if (intervalId)
                 clearInterval(intervalId);
             // 失败/中断也要清掉，不然「查询下载进度」会一直卡在旧任务上
             clearDownloadProgress(this.filepath);
-            const isRecoverable = (0, helpers_1.isRecoverableNetworkError)(error);
-            const isThrottling = (0, helpers_1.isThrottlingError)(error);
-            const errorDesc = (0, helpers_1.getErrorDescription)(error);
-            if (error instanceof axios_1.AxiosError) {
+            /**
+             * 自己掐断的（空闲超时 / 坏源看门狗）不能按「服务器重置」处理。
+             *
+             * Node 对 `request.abort()` 抛的是 `Error: aborted`（code ECONNRESET），
+             * 直接套 code→文案的映射就会打印成「连接被重置」，既误导排查、
+             * 又会让下面的「服务器断流自动降速」误判（把一个坏源当成风控）。
+             */
+            const idleTimeout = this.abortReason === 'timeout';
+            const slowSource = this.abortReason === 'slow';
+            const ownAbort = idleTimeout || slowSource;
+            const isRecoverable = ownAbort || (0, helpers_1.isRecoverableNetworkError)(error);
+            const isThrottling = !ownAbort && (0, helpers_1.isThrottlingError)(error);
+            const errorDesc = idleTimeout
+                ? `下载超时（${Math.round(this.timeout / 1000)} 秒内没有收到新数据）`
+                : slowSource
+                    ? '下载源速度过低，主动放弃该源'
+                    : (0, helpers_1.getErrorDescription)(error);
+            if (error instanceof axios_1.AxiosError && !ownAbort) {
                 const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
                 node_karin_1.logger.error(`请求失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
             }
             else {
-                node_karin_1.logger.error(`下载失败: ${errorDesc}`);
+                node_karin_1.logger.error(ownAbort ? `下载中断: ${errorDesc}` : `下载失败: ${errorDesc}`);
             }
             // 如果是断流错误，自动降速
             if (isThrottling && this.throttleConfig.enabled) {
@@ -415,6 +536,22 @@ class Downloader {
                     node_karin_1.logger.warn(`已达到最低速度限制 ${(0, helpers_1.formatBytes)(this.throttleConfig.minSpeed)}/s，无法继续降速`);
                 }
             }
+            /**
+             * 坏源优先换源。
+             *
+             * 同一份数据在别的镜像上往往能跑满带宽，而坏源上耗满 maxRetries 次
+             * （每次都要再等一个超时）纯属浪费时间；反过来，如果本轮已经传了好几 MB
+             * 只是被掐了一下，那就该留在原源续传，别把进度扔掉。
+             */
+            if ((slowSource || (idleTimeout && attemptBytes < SWITCH_IF_UNDER_BYTES)) && this.backupUrls.length > 0) {
+                const next = this.backupUrls.shift();
+                this.sourceSwitches++;
+                node_karin_1.logger.warn(`当前源不可用，换备用下载源 (${this.sourceSwitches}，剩余 ${this.backupUrls.length}): ` +
+                    `${safeHost(this.url)} -> ${safeHost(next)}`);
+                this.url = next;
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+                return this.download(progressCallback, 0);
+            }
             const nextDelay = (0, helpers_1.calculateBackoffDelay)(retryCount);
             if (retryCount < this.maxRetries) {
                 // 等待 writer 完全关闭，确保异步写入操作已完成，避免 stat 获取到不准确的文件大小
@@ -453,6 +590,9 @@ class Downloader {
                         if (isThrottling) {
                             node_karin_1.logger.warn('建议: 服务器可能有下载速度限制，请尝试在配置中降低 maxSpeed 参数');
                         }
+                        if (idleTimeout) {
+                            node_karin_1.logger.warn('提示: 这条直链所属的 CDN 节点（常见于 *.mcdn.bilivideo.cn 这类 PCDN）很可能已失效，稍后重试或换个画质通常会换到别的节点');
+                        }
                     }
                     else {
                         try {
@@ -468,6 +608,12 @@ class Downloader {
                 throw new Error(`在 ${this.maxRetries} 次尝试后下载失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
             }
         }
+        finally {
+            // 所有出口（成功 / 416 提前返回 / 换源 / 重试 / 抛错）都要把定时器和轮询清干净
+            clearTimers();
+            if (intervalId)
+                clearInterval(intervalId);
+        }
     }
     /**
      * 手动设置下载速度

package/lib/karin/module/utils/Network/Network.js

@@ -54,6 +54,7 @@ class Network {
     filepath;
     maxRetries;
     throttleConfig;
+    backupUrls;
     /**
      * 创建网络请求实例
      *
@@ -79,6 +80,7 @@ class Network {
         this.filepath = data.filepath ?? '';
         this.maxRetries = data.maxRetries ?? 3;
         this.throttleConfig = data.throttle;
+        this.backupUrls = data.backupUrls ?? [];
         // 创建 axios 实例
         this.axiosInstance = axios_1.default.create({
             timeout: this.timeout,
@@ -126,7 +128,9 @@ class Network {
      * @param retryCount 重试次数（内部使用）
      */
     async downloadStream(progressCallback, retryCount = 0) {
-        const downloader = new Downloader_1.Downloader(this.axiosInstance, this.url, this.filepath, this.headers, this.timeout, this.maxRetries, this.throttleConfig);
+        const downloader = new Downloader_1.Downloader(this.axiosInstance, this.url, this.filepath, this.headers, this.timeout, this.maxRetries, this.throttleConfig, 
+        // 拷贝一份：下载器内部会 shift 掉已经试过的地址
+        [...this.backupUrls]);
         return downloader.download(progressCallback, retryCount);
     }
     async getfetch() {

package/lib/karin/platform/bilibili/bilibili.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractArticleImages = exports.getvideosize = exports.bilibiliProcessVideos = exports.preferAvcStream = exports.isAvcStream = exports.parseAdditionalCard = exports.generateDecorationCard = exports.cover = exports.TimeFormatter = exports.Bilibili = void 0;
+exports.extractArticleImages = exports.getvideosize = exports.bilibiliProcessVideos = exports.preferAvcStream = exports.isAvcStream = exports.parseAdditionalCard = exports.generateDecorationCard = exports.cover = exports.TimeFormatter = exports.Bilibili = exports.buildDashUrlCandidates = void 0;
 const node_fs_1 = __importDefault(require("node:fs"));
 const ImageSlice_1 = require("../../module/utils/ImageSlice");
 const QqPanel_1 = require("../../module/utils/QqPanel");
@@ -65,6 +65,42 @@ const danmaku_1 = require("../../platform/bilibili/danmaku");
 const dynamic_text_1 = require("../../platform/bilibili/dynamic-text");
 const interactive_story_1 = require("../../platform/bilibili/interactive-story");
 let img;
+/**
+ * 一个地址是不是 PCDN 边缘节点。
+ *
+ * `xy120x240x109x22xy.mcdn.bilivideo.cn:8082/v1/resource/upgcxcode/...` 这种就是：
+ * 域名带 mcdn、带非标准端口、路径 `/v1/resource/`。
+ * 它们对本机来说常常是「TCP 连得上、响应头也正常，就是不吐数据」（实测 118 KB / 60 秒），
+ * 而同一份数据在 `upos-*` 镜像上能跑满带宽。
+ */
+const isPcdnUrl = (url) => /\.mcdn\.bilivideo\./i.test(url) || /\.pcdn\./i.test(url) || /\/v1\/resource\//i.test(url);
+/**
+ * 把一条 dash 流的直链整理成**按优先级排序**的候选列表。
+ *
+ * 排序规则（尽量不改变原来的行为，只在必要时动）：
+ *   1. `base_url` 不是 PCDN 时保持第一 —— 原来的行为不变；
+ *   2. `base_url` 是 PCDN 时，把非 PCDN 的备用地址提到前面；
+ *   3. 其余地址按接口给的顺序跟在后面。
+ *
+ * 下载器遇到「连得上但不吐数据」的源会自动换到下一个（见 Downloader 的坏源看门狗），
+ * 所以列表顺序就是换源顺序。
+ *
+ * @param stream dash 里的 video / audio 流对象
+ * @returns 去重且已排序的直链列表（可能为空）
+ */
+const buildDashUrlCandidates = (stream) => {
+    const raw = [stream?.base_url ?? stream?.baseUrl, ...(stream?.backup_url ?? stream?.backupUrl ?? [])];
+    const seen = new Set();
+    const urls = [];
+    for (const url of raw) {
+        if (typeof url !== 'string' || !/^https?:\/\//i.test(url) || seen.has(url))
+            continue;
+        seen.add(url);
+        urls.push(url);
+    }
+    return [...urls.filter((url) => !isPcdnUrl(url)), ...urls.filter(isPcdnUrl)];
+};
+exports.buildDashUrlCandidates = buildDashUrlCandidates;
 /** 评论请求统一使用匿名态，避免账号 Cookie 改变评论热度池结果。 */
 const bilibiliAnonymousRequestConfig = {
     headers: {
@@ -1359,15 +1395,24 @@ class Bilibili extends utils_1.Base {
         this.danmakuList = danmakuList;
         switch (this.islogin) {
             case true: {
-                node_karin_1.logger.debug('视频 URL:', this.Type === 'one_video' ? playUrlData.data?.dash?.video[0].base_url : playUrlData.result.dash.video[0].base_url);
+                const videoStream = this.Type === 'one_video' ? playUrlData.data?.dash?.video[0] : playUrlData.result.dash.video[0];
+                node_karin_1.logger.debug('视频 URL:', videoStream?.base_url);
                 // B站 CDN 需要正确的 Referer
                 const downloadHeaders = {
                     ...this.headers,
                     Referer: 'https://www.bilibili.com'
                 };
-                const bmp4Raw = await (0, utils_1.downloadFile)(this.Type === 'one_video' ? playUrlData.data?.dash?.video[0].base_url : playUrlData.result.dash.video[0].base_url, {
+                /**
+                 * 直链候选：`base_url`（常是 mcdn/PCDN 节点）+ `backup_url` 镜像。
+                 * 排在前面的先试，坏源由下载器自动换掉 —— 不然一个死节点就能让整个解析卡死。
+                 */
+                const videoUrls = (0, exports.buildDashUrlCandidates)(videoStream);
+                if (videoUrls.length === 0)
+                    throw new Error('没有拿到视频流直链（playurl 返回里没有 base_url）');
+                const bmp4Raw = await (0, utils_1.downloadFile)(videoUrls[0], {
                     title: `Bil_V_${this.Type === 'one_video' ? infoData && infoData.data.bvid : infoData && infoData.result.season_id}.m4s`,
-                    headers: downloadHeaders
+                    headers: downloadHeaders,
+                    backupUrls: videoUrls.slice(1)
                 });
                 // 修复 m4s 文件为标准 MP4
                 const videoPath = utils_1.Common.tempDri.video +
@@ -1379,14 +1424,18 @@ class Bilibili extends utils_1.Base {
                 }
                 // 删除原始 m4s 文件
                 await utils_1.Common.removeFile(bmp4Raw.filepath, true);
-                const audioUrl = this.Type === 'one_video' ? playUrlData.data?.dash?.audio?.[0]?.base_url : playUrlData.result.dash.audio?.[0]?.base_url;
+                const audioStream = this.Type === 'one_video' ? playUrlData.data?.dash?.audio?.[0] : playUrlData.result.dash.audio?.[0];
+                /** 音频候选同样带镜像，理由见上面视频那段 */
+                const audioUrls = (0, exports.buildDashUrlCandidates)(audioStream);
+                const audioUrl = audioUrls[0];
                 node_karin_1.logger.debug('音频 URL:', audioUrl);
                 /** 没有音频流（如纯视频稿件）时为 undefined，此时无从合成，直接发视频流 */
                 let bmp3;
                 if (audioUrl) {
                     const bmp3Raw = await (0, utils_1.downloadFile)(audioUrl, {
                         title: `Bil_A_${this.Type === 'one_video' ? infoData && infoData.data.bvid : infoData && infoData.result.season_id}.m4s`,
-                        headers: downloadHeaders
+                        headers: downloadHeaders,
+                        backupUrls: audioUrls.slice(1)
                     });
                     // 修复音频 m4s 文件为 m4a（AAC 音频不能直接转为 MP3 容器）
                     const audioPath = utils_1.Common.tempDri.video +

package/lib/karin/platform/bilibili/push.js

@@ -757,14 +757,21 @@ class Bilibilipush extends module_1.Base {
                                     const infoData = await this.amagi.bilibili.fetcher.fetchVideoInfo({
                                         bvid: data[dynamicId].Dynamic_Data.modules.module_dynamic.major.archive.bvid
                                     });
-                                    const mp4File = await (0, module_1.downloadFile)(playUrlData.data?.data?.dash?.video[0].base_url, {
+                                    /** 直链候选：base_url（可能是 mcdn/PCDN 节点）+ backup_url 镜像，坏源由下载器自动换 */
+                                    const videoUrls = (0, bilibili_1.buildDashUrlCandidates)(playUrlData.data?.data?.dash?.video[0]);
+                                    const audioUrls = (0, bilibili_1.buildDashUrlCandidates)(playUrlData.data?.data?.dash?.audio?.[0]);
+                                    if (videoUrls.length === 0)
+                                        break;
+                                    const mp4File = await (0, module_1.downloadFile)(videoUrls[0], {
                                         title: `Bil_V_${infoData.data.data.bvid}.mp4`,
-                                        headers: bilibiliBaseHeaders
+                                        headers: bilibiliBaseHeaders,
+                                        backupUrls: videoUrls.slice(1)
                                     });
-                                    const mp3File = audioUrl
-                                        ? await (0, module_1.downloadFile)(audioUrl, {
+                                    const mp3File = audioUrls.length > 0
+                                        ? await (0, module_1.downloadFile)(audioUrls[0], {
                                             title: `Bil_A_${infoData.data.data.bvid}.mp3`,
-                                            headers: bilibiliBaseHeaders
+                                            headers: bilibiliBaseHeaders,
+                                            backupUrls: audioUrls.slice(1)
                                         })
                                         : undefined;
                                     if (mp4File.filepath && (!mp3File || mp3File.filepath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koishi-plugin-kkk",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "抖音 / B站 / 快手 / 小红书 视频解析与动态推送，带 QQ 交互面板与弹幕烧录（karin-plugin-kkk 的 Koishi 移植版）",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/scripts/smoke-download-source-fallback.cjs

@@ -0,0 +1,166 @@
+/**
+ * 冒烟测试：下载器遇到「连得上但不吐数据」的坏源时的行为。
+ *
+ * 背景（用户实测）：B站 playurl 把直链指向 `*.mcdn.bilivideo.cn` 这类 PCDN 边缘节点，
+ * TCP 连得上、响应头也正常，就是 60 秒只吐 118 KB；而旧实现的定时器是
+ * **从请求开始算的 60 秒总超时**，于是任何大文件都永远下不完，
+ * 报错还被 Node 报成 `Error: aborted`（code ECONNRESET）→ 日志写成「连接被重置」。
+ *
+ * 这里用本地 HTTP 服务复现四种场景，全程只依赖本机、不碰外网：
+ *   1. 坏源 + 备用镜像：应当自动换源并下完（新增行为）
+ *   2. 只有坏源、没有备用：应当报「下载超时」，**不能**再报「连接被重置」
+ *   3. 健康但慢的源（总耗时远超 timeout）：应当下完（旧的 60 秒总超时会掐死它）
+ *   4. 涓流源（一直有数据但速度远低于阈值）+ 备用镜像：应当被看门狗换掉
+ *
+ * 走的是 lib 产物（真正跑的就是它），不是 src。
+ * 用法：node scripts/smoke-download-source-fallback.cjs
+ */
+const http = require('node:http')
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const axios = require('axios')
+
+const { Downloader } = require('../lib/karin/module/utils/Network/Downloader.js')
+
+/** 目标文件大小：8 MB（远大于 x64 回退的 256 KB 安全裕量） */
+const TOTAL = 8 * 1024 * 1024
+
+let failures = 0
+const check = (name, ok, extra = '') => {
+  console.log((ok ? '✅' : '❌') + ' ' + name + (extra ? ' | ' + extra : ''))
+  if (!ok) failures++
+}
+
+/** 收集日志，用于断言「换源」「超时」这类提示文案 */
+const logs = []
+const rawLog = console.log.bind(console)
+const rawWarn = console.warn.bind(console)
+console.log = (...args) => { logs.push(args.join(' ')); rawLog(...args) }
+console.warn = (...args) => { logs.push(args.join(' ')); rawWarn(...args) }
+
+const listen = (handler) => new Promise((resolve) => {
+  const server = http.createServer(handler)
+  server.listen(0, '127.0.0.1', () => resolve(server))
+})
+const urlOf = (server) => 'http://127.0.0.1:' + server.address().port + '/file'
+
+const parseRangeStart = (header) => {
+  if (!header) return 0
+  const raw = String(header).replace('bytes=', '').split('-')[0]
+  const start = Number(raw)
+  return Number.isFinite(start) && start > 0 ? start : 0
+}
+
+/** 正常源：支持 Range，快速把整份数据写完 */
+const goodHandler = (req, res) => {
+  const start = parseRangeStart(req.headers.range)
+  const length = TOTAL - start
+  res.writeHead(start > 0 ? 206 : 200, {
+    'content-type': 'application/octet-stream',
+    'content-length': String(length),
+    ...(start > 0 ? { 'content-range': 'bytes ' + start + '-' + (TOTAL - 1) + '/' + TOTAL } : {})
+  })
+  const chunk = Buffer.alloc(256 * 1024)
+  let sent = start
+  const pump = () => {
+    while (sent < TOTAL) {
+      const size = Math.min(chunk.length, TOTAL - sent)
+      sent += size
+      if (!res.write(chunk.subarray(0, size))) {
+        res.once('drain', pump)
+        return
+      }
+    }
+    res.end()
+  }
+  pump()
+}
+
+/** 坏源：发完响应头和 64 KB 就再也不吐数据，且不关连接（mcdn/PCDN 的典型表现） */
+const badHandler = (req, res) => {
+  res.writeHead(200, { 'content-type': 'application/octet-stream', 'content-length': String(TOTAL) })
+  res.write(Buffer.alloc(64 * 1024))
+}
+
+/** 涓流源：一直有数据，但只有 ~5 KB/s，远低于坏源看门狗阈值 */
+const trickleHandler = (req, res) => {
+  res.writeHead(200, { 'content-type': 'application/octet-stream', 'content-length': String(TOTAL) })
+  const timer = setInterval(() => { res.write(Buffer.alloc(1024)) }, 200)
+  res.on('close', () => clearInterval(timer))
+}
+
+/** 健康但慢的源：约 4 秒传完 8 MB（每 200 ms 一块），总耗时远超 timeout */
+const slowHandler = (req, res) => {
+  res.writeHead(200, { 'content-type': 'application/octet-stream', 'content-length': String(TOTAL) })
+  let sent = 0
+  const timer = setInterval(() => {
+    if (sent >= TOTAL) { clearInterval(timer); res.end(); return }
+    const size = Math.min(512 * 1024, TOTAL - sent)
+    sent += size
+    res.write(Buffer.alloc(size))
+  }, 250)
+  res.on('close', () => clearInterval(timer))
+}
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'kkk-dl-'))
+
+const runDownload = async (label, url, { timeout, retries = 3, backups = [] }) => {
+  const filepath = path.join(tmp, label + '.bin')
+  const instance = axios.create({ timeout, maxRedirects: 5, validateStatus: () => true })
+  const downloader = new Downloader(instance, url, filepath, {}, timeout, retries, { enabled: false }, backups)
+  const started = Date.now()
+  try {
+    const result = await downloader.download(() => {})
+    return { ok: true, bytes: fs.statSync(result.filepath).size, elapsed: Date.now() - started }
+  } catch (error) {
+    return { ok: false, message: String(error && error.message), bytes: fs.existsSync(filepath) ? fs.statSync(filepath).size : 0, elapsed: Date.now() - started }
+  }
+}
+
+const main = async () => {
+  const bad = await listen(badHandler)
+  const good = await listen(goodHandler)
+  const trickle = await listen(trickleHandler)
+  const slow = await listen(slowHandler)
+
+  // 1. 坏源 + 备用镜像 → 自动换源下完
+  logs.length = 0
+  const switched = await runDownload('switch', urlOf(bad), { timeout: 2000, backups: [urlOf(good)] })
+  check('坏源 + 备用镜像：下载成功', switched.ok, JSON.stringify(switched))
+  check('坏源 + 备用镜像：文件完整', switched.bytes === TOTAL, switched.bytes + '/' + TOTAL)
+  check('坏源 + 备用镜像：日志里有换源提示', logs.some((line) => line.includes('换备用下载源')), logs.filter((l) => l.includes('备用下载源')).join(' / '))
+
+  // 2. 只有坏源、没有备用 → 报「下载超时」，不报「连接被重置」
+  logs.length = 0
+  const timedOut = await runDownload('timeout', urlOf(bad), { timeout: 1500, retries: 0 })
+  check('无备用源：如预期失败', !timedOut.ok, JSON.stringify(timedOut))
+  check('无备用源：报「下载超时」', timedOut.message.includes('下载超时'), timedOut.message.slice(0, 160))
+  check('无备用源：不再误报「连接被重置」', !timedOut.message.includes('连接被重置'), timedOut.message.slice(0, 160))
+  check('无备用源：超时按空闲判定（约等于 timeout）', timedOut.elapsed < 1500 + 1500, timedOut.elapsed + 'ms')
+
+  // 3. 健康但慢的源：总耗时远超 timeout 也要下完（旧的 60 秒总超时会掐死它）
+  const slowRun = await runDownload('slow', urlOf(slow), { timeout: 1500, retries: 0 })
+  check('健康慢源：下载成功', slowRun.ok, JSON.stringify(slowRun))
+  check('健康慢源：文件完整', slowRun.bytes === TOTAL, slowRun.bytes + '/' + TOTAL)
+  check('健康慢源：确实是「比 timeout 慢」的场景', slowRun.elapsed > 1500 * 2, slowRun.elapsed + 'ms > 2x timeout')
+
+  // 4. 涓流源 + 备用镜像 → 看门狗换源（热身期 20s，这条最慢）
+  logs.length = 0
+  const watchdog = await runDownload('watchdog', urlOf(trickle), { timeout: 60000, retries: 1, backups: [urlOf(good)] })
+  check('涓流源：被看门狗换掉后下载成功', watchdog.ok, JSON.stringify(watchdog))
+  check('涓流源：文件完整', watchdog.bytes === TOTAL, watchdog.bytes + '/' + TOTAL)
+  check('涓流源：日志提示速度过低', logs.some((line) => line.includes('速度过低')), logs.filter((l) => l.includes('速度过低')).join(' / '))
+
+  for (const server of [bad, good, trickle, slow]) server.close()
+  fs.rmSync(tmp, { recursive: true, force: true })
+
+  console.log('')
+  console.log(failures ? '失败 ' + failures + ' 项' : '全部通过')
+  process.exit(failures ? 1 : 0)
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exit(1)
+})

package/src/karin/module/utils/Base.ts

@@ -100,6 +100,14 @@ export type downLoadFileOptions = {
   headers?: (RawAxiosRequestHeaders & MethodsHeaders) | AxiosHeaders
   /** 文件保存路径 */
   filepath?: string
+  /**
+   * 备用直链（按顺序尝试）。
+   *
+   * B站 dash 的 `backup_url` 就是干这个用的：`base_url` 常常指向
+   * `*.mcdn.bilivideo.cn` 这类 PCDN 节点，连得上却不吐数据；
+   * 把镜像地址带上，下载器就能在坏源上自动换过去。
+   */
+  backupUrls?: string[]
 }
 
 /**
@@ -526,15 +534,26 @@ export const downloadFile = async (videoUrl: string, opt: downLoadFileOptions):
     minSpeed: (uploadConfig.downloadMinSpeed ?? 1) * 1024 * 1024 // MB/s -> bytes/s
   }
 
+  /**
+   * 速度采样点。速度必须按「两次回调之间的增量」算，不能按「累计字节 ÷ 总耗时」：
+   * 后者把重试的退避等待也算进分母，断点续传时分子还会被重置回续传点，
+   * 于是明明在正常下载也会显示成 `0.0 MB/s 剩余: 661min`（用户实测反馈）。
+   */
+  let lastSampleBytes = 0
+  let lastSampleAt = startTime
+  /** 平滑后的速度（byte/s） */
+  let smoothSpeed = 0
+
   try {
     // 使用 networks 类进行文件下载，并通过回调函数实时更新下载进度
     const { filepath, totalBytes } = await new Networks({
       url: videoUrl,
       headers: opt.headers ?? baseHeaders,
       filepath: opt.filepath ?? Common.tempDri.video + opt.title,
-      timeout: 60000, // 增加超时时间
+      timeout: 60000, // 空闲超时（连续 60s 没有新数据才算超时），传输途中会不断续期
       maxRetries: 3, // 增加重试次数
-      throttle: throttleConfig
+      throttle: throttleConfig,
+      backupUrls: opt.backupUrls
     }).downloadStream((downloadedBytes, totalBytes) => {
       // 定义进度条长度及生成进度条字符串的函数
       const barLength = 45
@@ -552,16 +571,27 @@ export const downloadFile = async (videoUrl: string, opt: downLoadFileOptions):
       const red = Math.floor(255 - (255 * progressPercentage) / 100) // 红色分量随进度减少
       const coloredPercentage = logger.chalk.rgb(red, 255, 0)(`${progressPercentage.toFixed(1)}%`)
 
-      // 计算下载速度（MB/s）
-      const elapsedTime = (Date.now() - startTime) / 1000
-      const speed = downloadedBytes / elapsedTime
+      // 计算下载速度（MB/s）：增量法 + 一点平滑，避免数字乱跳
+      const sampleAt = Date.now()
+      const elapsedSinceSample = (sampleAt - lastSampleAt) / 1000
+      if (elapsedSinceSample >= 0.2) {
+        // 断点续传时 downloadedBytes 会往回退，增量按 0 处理
+        const instant = Math.max(0, downloadedBytes - lastSampleBytes) / elapsedSinceSample
+        smoothSpeed = smoothSpeed > 0 ? smoothSpeed * 0.6 + instant * 0.4 : instant
+        lastSampleBytes = downloadedBytes
+        lastSampleAt = sampleAt
+      }
+      const speed = smoothSpeed
       const formattedSpeed = (speed / 1048576).toFixed(1) + ' MB/s'
 
-      // 计算剩余时间
+      // 计算剩余时间（速度还没出来时不瞎猜）
       const remainingBytes = totalBytes - downloadedBytes // 剩余字节数
-      const remainingTime = remainingBytes / speed // 剩余时间（秒）
-      const formattedRemainingTime =
-        remainingTime > 60 ? `${Math.floor(remainingTime / 60)}min ${Math.floor(remainingTime % 60)}s` : `${remainingTime.toFixed(0)}s`
+      const remainingTime = speed > 1024 ? remainingBytes / speed : Number.POSITIVE_INFINITY
+      const formattedRemainingTime = !Number.isFinite(remainingTime)
+        ? '--'
+        : remainingTime > 60
+          ? `${Math.floor(remainingTime / 60)}min ${Math.floor(remainingTime % 60)}s`
+          : `${remainingTime.toFixed(0)}s`
 
       // 计算已下载和总下载的文件大小（MB）
       const downloadedSizeMB = (downloadedBytes / 1048576).toFixed(1)

package/src/karin/module/utils/Network/Downloader.ts

@@ -180,9 +180,45 @@ export function listActiveDownloads (): DownloadProgressEntry[] {
   return result.sort((left, right) => right.at - left.at)
 }
 
+/* ------------------------------------------------------------------ *
+ * 坏源判定阈值
+ * ------------------------------------------------------------------ */
+
+/**
+ * 换源前的热身时间：新源先给这么久证明自己。
+ *
+ * B站 playurl 经常把直链指向 `*.mcdn.bilivideo.cn` 这类 PCDN 边缘节点：
+ * TCP 连得上、响应头也回得来（content-length 都正常），就是几乎不吐数据
+ * （实测 118 KB / 60 秒 ≈ 2 KB/s）。在这种源上干等毫无意义。
+ */
+const STALL_WARMUP_MS = 20_000
+
+/** 热身期过后速度仍低于这个值（byte/s）且还有备用地址时，判定为坏源并换源 */
+const STALL_MIN_SPEED = 64 * 1024
+
+/**
+ * 重试同一个源之前，本轮至少要传这么多字节，才值得原地重试。
+ *
+ * 传了几 MB 再断，说明源本身是好的（只是被掐了），留着进度续传最划算；
+ * 传了几百 KB 就断，那就是坏源，直接换。
+ */
+const SWITCH_IF_UNDER_BYTES = 4 * 1024 * 1024
+
+/** 单次尝试的硬上限：既没数据、又没有备用源可换的「涓流」源不能永远挂着 */
+const MAX_ATTEMPT_MS = 30 * 60_000
+
+/** 打个码的地址（只留 host，别把带签名的完整直链写进日志） */
+const safeHost = (url: string): string => {
+  try {
+    return new URL(url).host
+  } catch {
+    return '(非法地址)'
+  }
+}
+
 /**
  * 文件下载器
- * 支持断点续传、限速下载、自动重试
+ * 支持断点续传、限速下载、自动重试，以及**坏源自动换源**
  */
 export class Downloader {
   private axiosInstance: AxiosInstance
@@ -194,6 +230,19 @@ export class Downloader {
   private throttleConfig: ThrottleConfig
   private currentSpeed: number
   private consecutiveResets: number
+  /** 备用直链：当前源被判定为坏源时按顺序换过去（B站 dash 的 backup_url） */
+  private backupUrls: string[]
+  /**
+   * 本次尝试「被自己掐断」的原因：
+   * - `timeout`：空闲超时（连续 timeout 毫秒没收到数据）
+   * - `slow`：坏源看门狗主动放弃
+   *
+   * 自己掐断的必须和「服务器重置」区分开 —— Node 把 abort 报成
+   * `Error: aborted`（code ECONNRESET），照抄进日志会把排查方向带偏。
+   */
+  private abortReason: 'timeout' | 'slow' | null = null
+  /** 已经换过几次源（仅用于日志） */
+  private sourceSwitches = 0
 
   constructor(
     axiosInstance: AxiosInstance,
@@ -202,7 +251,8 @@ export class Downloader {
     headers: Record<string, string>,
     timeout: number,
     maxRetries: number,
-    throttleConfig?: Partial<ThrottleConfig>
+    throttleConfig?: Partial<ThrottleConfig>,
+    backupUrls: string[] = []
   ) {
     this.axiosInstance = axiosInstance
     this.url = url
@@ -213,6 +263,7 @@ export class Downloader {
     this.throttleConfig = { ...DEFAULT_THROTTLE_CONFIG, ...throttleConfig }
     this.currentSpeed = this.throttleConfig.maxSpeed
     this.consecutiveResets = 0
+    this.backupUrls = [...backupUrls]
   }
 
   /**
@@ -231,11 +282,49 @@ export class Downloader {
       throw new Error('未指定文件保存路径: filepath 为空')
     }
 
+    // 每次尝试都从「没被掐断」开始
+    this.abortReason = null
+
     const controller = new AbortController()
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout)
     let intervalId: NodeJS.Timeout | null = null
     let throttleStream: ThrottleStream | null = null
     let writer: fs.WriteStream | null = null
+    /** 本轮尝试收到的字节数（用于坏源判定，断点续传时只算这一轮新增的） */
+    let attemptBytes = 0
+    /** 本轮尝试的开始时间 */
+    const attemptStart = Date.now()
+
+    let timeoutId: NodeJS.Timeout | null = null
+    let attemptCapId: NodeJS.Timeout | null = null
+    const clearTimers = () => {
+      if (timeoutId) clearTimeout(timeoutId)
+      if (attemptCapId) clearTimeout(attemptCapId)
+      timeoutId = null
+      attemptCapId = null
+    }
+    /**
+     * 重新计时：**这是空闲超时，不是总时长超时**。
+     *
+     * 以前这里是一个从头开始算的定时器（`setTimeout(abort, 60000)` 并且全程不再重置），
+     * 于是任何需要超过 60 秒的文件（按 1.5 MB/s 算就是 90 MB 以上）都**永远下不完**：
+     * 到点就被 abort，而 Node 把「自己 abort」报成 `Error: aborted`（code ECONNRESET），
+     * 日志里就成了「下载失败: 连接被重置 (ECONNRESET): aborted」，把所有排查方向都带偏。
+     * 现在每收到一块数据就重新计时，只有**真的没数据**才超时。
+     */
+    const armIdleTimeout = () => {
+      if (this.timeout <= 0) return
+      if (timeoutId) clearTimeout(timeoutId)
+      timeoutId = setTimeout(() => {
+        this.abortReason = 'timeout'
+        controller.abort()
+      }, this.timeout)
+    }
+    armIdleTimeout()
+    // 兜底：涓流源（一直有数据但慢得离谱、又没有备用源）不能在这一次尝试里挂几个小时
+    attemptCapId = setTimeout(() => {
+      this.abortReason = 'timeout'
+      controller.abort()
+    }, MAX_ATTEMPT_MS)
 
     try {
       // 检查断点续传
@@ -282,7 +371,7 @@ export class Downloader {
       })
 
       const response = await this.axiosInstance(requestConfig)
-      clearTimeout(timeoutId)
+      // 注意：这里**不**清除定时器 —— 传输阶段的空闲超时还得靠它（每收到数据会重新计时）
 
       // 检查 HTTP 状态码
       // 416 Range Not Satisfiable
@@ -387,12 +476,35 @@ export class Downloader {
       }
 
       const interval = totalBytes > 0 && totalBytes < 10 * 1024 * 1024 ? 1000 : 500
-      intervalId = setInterval(printProgress, interval)
+
+      /**
+       * 坏源看门狗：有备用地址时，热身期过了速度还低得离谱就直接放弃这个源。
+       *
+       * 没有备用地址时不介入 —— 慢总比失败强，真正的死源交给空闲超时兜底。
+       */
+      const checkStall = () => {
+        if (this.backupUrls.length === 0) return
+        const elapsed = Date.now() - attemptStart
+        if (elapsed < STALL_WARMUP_MS) return
+        const speed = attemptBytes / (elapsed / 1000)
+        if (speed >= STALL_MIN_SPEED) return
+        logger.warn(`当前下载源速度过低 (${formatBytes(Math.round(speed))}/s)，准备切换备用地址`)
+        this.abortReason = 'slow'
+        controller.abort()
+      }
+
+      intervalId = setInterval(() => {
+        printProgress()
+        checkStall()
+      }, interval)
 
       // 创建计数流
       const counterStream = new Transform({
         transform(chunk, encoding, callback) {
           downloadedBytes += chunk.length
+          attemptBytes += chunk.length
+          // 还有数据在流，说明这个源活着：把空闲超时往后推
+          armIdleTimeout()
           callback(null, chunk)
         }
       })
@@ -406,8 +518,6 @@ export class Downloader {
         await pipeline(response.data, counterStream, writer as fs.WriteStream)
       }
 
-      if (intervalId) clearInterval(intervalId)
-
       // pipeline 已经等待所有流完成，包括 writer 的 finish 事件
       logger.debug('文件下载并写入完成')
 
@@ -456,20 +566,34 @@ export class Downloader {
         totalBytes: totalBytes > 0 ? totalBytes : downloadedBytes
       }
     } catch (error) {
-      clearTimeout(timeoutId)
+      clearTimers()
       if (intervalId) clearInterval(intervalId)
       // 失败/中断也要清掉，不然「查询下载进度」会一直卡在旧任务上
       clearDownloadProgress(this.filepath)
 
-      const isRecoverable = isRecoverableNetworkError(error)
-      const isThrottling = isThrottlingError(error)
-      const errorDesc = getErrorDescription(error)
-
-      if (error instanceof AxiosError) {
+      /**
+       * 自己掐断的（空闲超时 / 坏源看门狗）不能按「服务器重置」处理。
+       *
+       * Node 对 `request.abort()` 抛的是 `Error: aborted`（code ECONNRESET），
+       * 直接套 code→文案的映射就会打印成「连接被重置」，既误导排查、
+       * 又会让下面的「服务器断流自动降速」误判（把一个坏源当成风控）。
+       */
+      const idleTimeout = this.abortReason === 'timeout'
+      const slowSource = this.abortReason === 'slow'
+      const ownAbort = idleTimeout || slowSource
+      const isRecoverable = ownAbort || isRecoverableNetworkError(error)
+      const isThrottling = !ownAbort && isThrottlingError(error)
+      const errorDesc = idleTimeout
+        ? `下载超时（${Math.round(this.timeout / 1000)} 秒内没有收到新数据）`
+        : slowSource
+          ? '下载源速度过低，主动放弃该源'
+          : getErrorDescription(error)
+
+      if (error instanceof AxiosError && !ownAbort) {
         const sanitized = sanitizeHeaders(this.headers)
         logger.error(`请求失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`)
       } else {
-        logger.error(`下载失败: ${errorDesc}`)
+        logger.error(ownAbort ? `下载中断: ${errorDesc}` : `下载失败: ${errorDesc}`)
       }
 
       // 如果是断流错误，自动降速
@@ -487,6 +611,25 @@ export class Downloader {
         }
       }
 
+      /**
+       * 坏源优先换源。
+       *
+       * 同一份数据在别的镜像上往往能跑满带宽，而坏源上耗满 maxRetries 次
+       * （每次都要再等一个超时）纯属浪费时间；反过来，如果本轮已经传了好几 MB
+       * 只是被掐了一下，那就该留在原源续传，别把进度扔掉。
+       */
+      if ((slowSource || (idleTimeout && attemptBytes < SWITCH_IF_UNDER_BYTES)) && this.backupUrls.length > 0) {
+        const next = this.backupUrls.shift() as string
+        this.sourceSwitches++
+        logger.warn(
+          `当前源不可用，换备用下载源 (${this.sourceSwitches}，剩余 ${this.backupUrls.length}): ` +
+          `${safeHost(this.url)} -> ${safeHost(next)}`
+        )
+        this.url = next
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+        return this.download(progressCallback, 0)
+      }
+
       const nextDelay = calculateBackoffDelay(retryCount)
 
       if (retryCount < this.maxRetries) {
@@ -528,6 +671,9 @@ export class Downloader {
             if (isThrottling) {
               logger.warn('建议: 服务器可能有下载速度限制，请尝试在配置中降低 maxSpeed 参数')
             }
+            if (idleTimeout) {
+              logger.warn('提示: 这条直链所属的 CDN 节点（常见于 *.mcdn.bilivideo.cn 这类 PCDN）很可能已失效，稍后重试或换个画质通常会换到别的节点')
+            }
           } else {
             try {
               fs.unlinkSync(this.filepath)
@@ -541,6 +687,10 @@ export class Downloader {
         const sanitized = sanitizeHeaders(this.headers)
         throw new Error(`在 ${this.maxRetries} 次尝试后下载失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`)
       }
+    } finally {
+      // 所有出口（成功 / 416 提前返回 / 换源 / 重试 / 抛错）都要把定时器和轮询清干净
+      clearTimers()
+      if (intervalId) clearInterval(intervalId)
     }
   }
 

package/src/karin/module/utils/Network/Network.ts

@@ -24,6 +24,7 @@ export class Network {
   private filepath: string
   private maxRetries: number
   private throttleConfig?: Partial<ThrottleConfig>
+  private backupUrls: string[]
 
   /**
    * 创建网络请求实例
@@ -35,7 +36,7 @@ export class Network {
    *
    * @param data - 配置对象
    */
-  constructor(data: NetworksConfigType & { throttle?: Partial<ThrottleConfig> }) {
+  constructor(data: NetworksConfigType & { throttle?: Partial<ThrottleConfig>; backupUrls?: string[] }) {
     this.headers = data.headers ? Object.fromEntries(Object.entries(data.headers).map(([key, value]) => [key, String(value)])) : {}
 
     // 合并默认头
@@ -52,6 +53,7 @@ export class Network {
     this.filepath = data.filepath ?? ''
     this.maxRetries = data.maxRetries ?? 3
     this.throttleConfig = data.throttle
+    this.backupUrls = data.backupUrls ?? []
 
     // 创建 axios 实例
     this.axiosInstance = axios.create({
@@ -120,7 +122,9 @@ export class Network {
       this.headers,
       this.timeout,
       this.maxRetries,
-      this.throttleConfig
+      this.throttleConfig,
+      // 拷贝一份：下载器内部会 shift 掉已经试过的地址
+      [...this.backupUrls]
     )
 
     return downloader.download(progressCallback, retryCount)

package/src/karin/platform/bilibili/bilibili.ts

@@ -81,6 +81,52 @@ import { BilibiliDataTypes } from '@/types'
 let img: ElementTypes[]
 type videoDownloadUrlList = BilibiliVideoStreamResponse['data']['dash']['video']
 
+/**
+ * 一条 dash 流里能拿来下载的地址（video / audio 都是这个形状）
+ */
+type DashStreamUrls = {
+  base_url?: string
+  baseUrl?: string
+  backup_url?: string[]
+  backupUrl?: string[]
+}
+
+/**
+ * 一个地址是不是 PCDN 边缘节点。
+ *
+ * `xy120x240x109x22xy.mcdn.bilivideo.cn:8082/v1/resource/upgcxcode/...` 这种就是：
+ * 域名带 mcdn、带非标准端口、路径 `/v1/resource/`。
+ * 它们对本机来说常常是「TCP 连得上、响应头也正常，就是不吐数据」（实测 118 KB / 60 秒），
+ * 而同一份数据在 `upos-*` 镜像上能跑满带宽。
+ */
+const isPcdnUrl = (url: string) => /\.mcdn\.bilivideo\./i.test(url) || /\.pcdn\./i.test(url) || /\/v1\/resource\//i.test(url)
+
+/**
+ * 把一条 dash 流的直链整理成**按优先级排序**的候选列表。
+ *
+ * 排序规则（尽量不改变原来的行为，只在必要时动）：
+ *   1. `base_url` 不是 PCDN 时保持第一 —— 原来的行为不变；
+ *   2. `base_url` 是 PCDN 时，把非 PCDN 的备用地址提到前面；
+ *   3. 其余地址按接口给的顺序跟在后面。
+ *
+ * 下载器遇到「连得上但不吐数据」的源会自动换到下一个（见 Downloader 的坏源看门狗），
+ * 所以列表顺序就是换源顺序。
+ *
+ * @param stream dash 里的 video / audio 流对象
+ * @returns 去重且已排序的直链列表（可能为空）
+ */
+export const buildDashUrlCandidates = (stream?: DashStreamUrls): string[] => {
+  const raw = [stream?.base_url ?? stream?.baseUrl, ...(stream?.backup_url ?? stream?.backupUrl ?? [])]
+  const seen = new Set<string>()
+  const urls: string[] = []
+  for (const url of raw) {
+    if (typeof url !== 'string' || !/^https?:\/\//i.test(url) || seen.has(url)) continue
+    seen.add(url)
+    urls.push(url)
+  }
+  return [...urls.filter((url) => !isPcdnUrl(url)), ...urls.filter(isPcdnUrl)]
+}
+
 /** 评论请求统一使用匿名态，避免账号 Cookie 改变评论热度池结果。 */
 const bilibiliAnonymousRequestConfig = {
   headers: {
@@ -1520,10 +1566,9 @@ export class Bilibili extends Base {
     this.danmakuList = danmakuList
     switch (this.islogin) {
       case true: {
-        logger.debug(
-          '视频 URL:',
-          this.Type === 'one_video' ? playUrlData.data?.dash?.video[0].base_url : playUrlData.result.dash.video[0].base_url
-        )
+        const videoStream: DashStreamUrls | undefined =
+          this.Type === 'one_video' ? playUrlData.data?.dash?.video[0] : playUrlData.result.dash.video[0]
+        logger.debug('视频 URL:', videoStream?.base_url)
 
         // B站 CDN 需要正确的 Referer
         const downloadHeaders = {
@@ -1531,13 +1576,18 @@ export class Bilibili extends Base {
           Referer: 'https://www.bilibili.com'
         }
 
-        const bmp4Raw = await downloadFile(
-          this.Type === 'one_video' ? playUrlData.data?.dash?.video[0].base_url : playUrlData.result.dash.video[0].base_url,
-          {
-            title: `Bil_V_${this.Type === 'one_video' ? infoData && infoData.data.bvid : infoData && infoData.result.season_id}.m4s`,
-            headers: downloadHeaders
-          }
-        )
+        /**
+         * 直链候选：`base_url`（常是 mcdn/PCDN 节点）+ `backup_url` 镜像。
+         * 排在前面的先试，坏源由下载器自动换掉 —— 不然一个死节点就能让整个解析卡死。
+         */
+        const videoUrls = buildDashUrlCandidates(videoStream)
+        if (videoUrls.length === 0) throw new Error('没有拿到视频流直链（playurl 返回里没有 base_url）')
+
+        const bmp4Raw = await downloadFile(videoUrls[0], {
+          title: `Bil_V_${this.Type === 'one_video' ? infoData && infoData.data.bvid : infoData && infoData.result.season_id}.m4s`,
+          headers: downloadHeaders,
+          backupUrls: videoUrls.slice(1)
+        })
 
         // 修复 m4s 文件为标准 MP4
         const videoPath =
@@ -1551,8 +1601,11 @@ export class Bilibili extends Base {
         // 删除原始 m4s 文件
         await Common.removeFile(bmp4Raw.filepath, true)
 
-        const audioUrl =
-          this.Type === 'one_video' ? playUrlData.data?.dash?.audio?.[0]?.base_url : playUrlData.result.dash.audio?.[0]?.base_url
+        const audioStream: DashStreamUrls | undefined =
+          this.Type === 'one_video' ? playUrlData.data?.dash?.audio?.[0] : playUrlData.result.dash.audio?.[0]
+        /** 音频候选同样带镜像，理由见上面视频那段 */
+        const audioUrls = buildDashUrlCandidates(audioStream)
+        const audioUrl = audioUrls[0]
         logger.debug('音频 URL:', audioUrl)
 
         /** 没有音频流（如纯视频稿件）时为 undefined，此时无从合成，直接发视频流 */
@@ -1560,7 +1613,8 @@ export class Bilibili extends Base {
         if (audioUrl) {
           const bmp3Raw = await downloadFile(audioUrl, {
             title: `Bil_A_${this.Type === 'one_video' ? infoData && infoData.data.bvid : infoData && infoData.result.season_id}.m4s`,
-            headers: downloadHeaders
+            headers: downloadHeaders,
+            backupUrls: audioUrls.slice(1)
           })
 
           // 修复音频 m4s 文件为 m4a（AAC 音频不能直接转为 MP3 容器）

package/src/karin/platform/bilibili/push.ts

@@ -34,7 +34,7 @@ import {
 } from '@/module'
 import { bilibiliFetcher } from '@/module/utils/amagiClient'
 import { Config } from '@/module/utils/Config'
-import { bilibiliProcessVideos, generateDecorationCard, getvideosize, parseAdditionalCard, TimeFormatter } from '@/platform/bilibili'
+import { bilibiliProcessVideos, buildDashUrlCandidates, generateDecorationCard, getvideosize, parseAdditionalCard, TimeFormatter } from '@/platform/bilibili'
 import {
   buildBilibiliArticleRichText,
   buildBilibiliDynamicRichText,
@@ -903,14 +903,20 @@ export class Bilibilipush extends Base {
                   const infoData = await this.amagi.bilibili.fetcher.fetchVideoInfo({
                     bvid: data[dynamicId].Dynamic_Data.modules.module_dynamic.major.archive.bvid
                   })
-                  const mp4File = await downloadFile(playUrlData.data?.data?.dash?.video[0].base_url, {
+                  /** 直链候选：base_url（可能是 mcdn/PCDN 节点）+ backup_url 镜像，坏源由下载器自动换 */
+                  const videoUrls = buildDashUrlCandidates(playUrlData.data?.data?.dash?.video[0])
+                  const audioUrls = buildDashUrlCandidates(playUrlData.data?.data?.dash?.audio?.[0])
+                  if (videoUrls.length === 0) break
+                  const mp4File = await downloadFile(videoUrls[0], {
                     title: `Bil_V_${infoData.data.data.bvid}.mp4`,
-                    headers: bilibiliBaseHeaders
+                    headers: bilibiliBaseHeaders,
+                    backupUrls: videoUrls.slice(1)
                   })
-                  const mp3File = audioUrl
-                    ? await downloadFile(audioUrl, {
+                  const mp3File = audioUrls.length > 0
+                    ? await downloadFile(audioUrls[0], {
                         title: `Bil_A_${infoData.data.data.bvid}.mp3`,
-                        headers: bilibiliBaseHeaders
+                        headers: bilibiliBaseHeaders,
+                        backupUrls: audioUrls.slice(1)
                       })
                     : undefined
 

package/src/karin/types/netrorks/NetworksConfigType.ts

@@ -58,4 +58,9 @@ export interface NetworksConfigType {
    * 当下载速度过快导致连接被重置时，会自动降速重试
    */
   throttle?: ThrottleConfig
+  /**
+   * 备用直链：当前直链被判定为坏源（连得上但不吐数据）时，下载器按顺序换过去。
+   * B站 dash 的 `backup_url` 就属于这种镜像地址。
+   */
+  backupUrls?: string[]
 }