@bililive-tools/douyin-recorder 1.6.0 → 1.7.1

package/README.md

@@ -46,8 +46,9 @@ interface Options {
   useServerTimestamp?: boolean; // 控制弹幕是否使用服务端时间戳，默认为true
   doubleScreen?: boolean; // 是否使用双屏直播流，开启后如果是双屏直播，那么就使用拼接的流，默认为true
   recorderType?: "auto" | "ffmpeg" | "mesio"; // 底层录制器，使用mesio时videoFormat参数无效
-  auth?: string; // 传递cookie，
-  api?: "web" | "webHTML"; // 使用不同的接口
+  auth?: string; // 传递cookie
+  uid?: string; // 参数为 sec_user_uid 参数
+  api?: "web" | "webHTML" | "mobile" | "userHTML" | "balance" | "random"; // 使用不同的接口，默认使用web，具体区别见文档
 }
 ```
 
@@ -77,6 +78,19 @@ const url = "https://live.douyin.com/203641303310";
 const { id } = await provider.resolveChannelInfoFromURL(url);
 ```
 
+## 不同请求接口的区别
+
+`mobile` 及 `userHTML` 必须传入 `uid` 参数
+
+| 描述             | 备注                                     |
+| ---------------- | ---------------------------------------- |
+| web直播间接口    | 效果不错                                 |
+| mobile直播间接口 | 不易风控，无验证码，海外IP可能无法使用   |
+| 直播间web解析    | 易风控，有验证码，单个接口1M流量         |
+| 用户web解析      | 不易风控，海外IP无法使用，单个接口1M流量 |
+| 负载均衡         | 使用负载均衡算法来分摊防止风控           |
+| 随机             | 从几个接口里挑一个                       |
+
 # 协议
 
 与原项目保存一致为 LGPL

package/lib/douyin_api.d.ts

@@ -1,3 +1,4 @@
+import type { APIType, RealAPIType } from "./types.js";
 /**
  * 从抖音短链接解析得到直播间ID
  * @param shortURL 短链接，如 https://v.douyin.com/DpfoBLAXoHM/
@@ -8,7 +9,8 @@ export declare const getCookie: () => Promise<string>;
 export declare function getRoomInfo(webRoomId: string, opts?: {
     auth?: string;
     doubleScreen?: boolean;
-    api?: "web" | "webHTML";
+    api?: APIType;
+    uid?: string | number;
 }): Promise<{
     living: boolean;
     roomId: string;
@@ -19,6 +21,8 @@ export declare function getRoomInfo(webRoomId: string, opts?: {
     avatar: string;
     cover: string;
     liveId: string;
+    uid: string;
+    api: RealAPIType;
 }>;
 /**
  * 解析抖音号

package/lib/douyin_api.js

@@ -104,7 +104,107 @@ function generateNonce() {
     return nonce;
 }
 /**
- * 通过解析html页面来获取房间数据
+ * 随机选择一个可用的 API 接口
+ * @returns 随机选择的 API 类型
+ */
+function selectRandomAPI() {
+    const availableAPIs = ["web", "webHTML", "mobile", "userHTML"];
+    const randomIndex = Math.floor(Math.random() * availableAPIs.length);
+    return availableAPIs[randomIndex];
+}
+/**
+ * 通过解析直播html页面来获取房间数据
+ * @param secUserId
+ * @param opts
+ */
+async function getRoomInfoByUserWeb(secUserId, opts = {}) {
+    const url = `https://www.douyin.com/user/${secUserId}`;
+    const ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36 Edg/133.0.0.0";
+    let nonce = "068ea1c0100bb2c06590f";
+    try {
+        nonce = await getNonce(url);
+    }
+    catch (error) {
+        console.warn("获取nonce失败，使用默认值", error);
+    }
+    let cookies = undefined;
+    if (opts.auth) {
+        cookies = opts.auth;
+    }
+    else {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const signed = get__ac_signature(timestamp, url, nonce, ua);
+        cookies = `__ac_nonce=${nonce}; __ac_signature=${signed}; __ac_referer=__ac_blank`;
+    }
+    const res = await axios.get(url, {
+        headers: {
+            "User-Agent": ua,
+            cookie: cookies,
+        },
+    });
+    if (res.data.includes("验证码")) {
+        throw new Error("需要验证码，请在浏览器中打开链接获取" + url);
+    }
+    if (!res.data.includes("直播中")) {
+        return {
+            living: false,
+            nickname: "",
+            sec_uid: "",
+            avatar: "",
+            api: "webHTML",
+            room: null,
+        };
+    }
+    const userRegex = /(\{\\"user\\":.*?)\]\\n"\]\)/;
+    // fs.writeFileSync("douyin.html", res.data);
+    const userMatch = res.data.match(userRegex);
+    if (!userMatch) {
+        throw new Error("No match found in HTML");
+    }
+    let userJsonStr = userMatch[1];
+    userJsonStr = userJsonStr
+        .replace(/\\"/g, '"')
+        .replace(/\\"/g, '"')
+        .replace(/"\$\w+"/g, "null");
+    // const roomRegex = /(\{\\"common\\":.*?)"\]\)/;
+    // const roomMatch = res.data.match(roomRegex);
+    // if (!roomMatch) {
+    //   throw new Error("No room match found in HTML");
+    // }
+    // let roomJsonStr = roomMatch[1];
+    // roomJsonStr = roomJsonStr
+    //   .replace(/\\"/g, '"')
+    //   .replace(/\\"/g, '"')
+    //   .replace(/"\$\w+"/g, "null");
+    try {
+        // console.log(userJsonStr);
+        const userData = JSON.parse(userJsonStr);
+        // console.log(JSON.stringify(userData, null, 2));
+        // const roomData = JSON.parse(roomJsonStr);
+        // console.log(roomData);
+        // const roomInfo = data.state.roomStore.roomInfo;
+        // const streamData = data.state.streamStore.streamData;
+        return {
+            living: userData?.user?.user?.roomData?.status === 2,
+            nickname: userData?.user?.user?.nickname ?? "",
+            sec_uid: userData?.user?.user?.secUid ?? "",
+            avatar: userData?.user?.user?.avatar ?? "",
+            api: "webHTML",
+            room: {
+                title: "",
+                cover: "",
+                id_str: userData?.user?.user?.roomIdStr,
+                stream_url: null,
+            },
+        };
+    }
+    catch (e) {
+        console.error("Failed to parse JSON:", e);
+        throw e;
+    }
+}
+/**
+ * 通过解析用户html页面来获取房间数据
  * @param webRoomId
  * @param opts
  */
@@ -140,15 +240,17 @@ async function getRoomInfoByHtml(webRoomId, opts = {}) {
         const roomInfo = data.state.roomStore.roomInfo;
         const streamData = data.state.streamStore.streamData;
         return {
-            living: roomInfo.room.status === 2,
-            nickname: roomInfo.anchor.nickname,
-            avatar: roomInfo.anchor?.avatar_thumb?.url_list?.[0],
+            living: roomInfo?.room?.status === 2,
+            nickname: roomInfo?.anchor?.nickname ?? "",
+            sec_uid: roomInfo?.anchor?.sec_uid ?? "",
+            avatar: roomInfo?.anchor?.avatar_thumb?.url_list?.[0] ?? "",
+            api: "userHTML",
             room: {
-                title: roomInfo.room.title,
-                cover: roomInfo.room.cover?.url_list?.[0],
-                id_str: roomInfo.room.id_str,
+                title: roomInfo?.room?.title ?? "",
+                cover: roomInfo?.room?.cover?.url_list?.[0] ?? "",
+                id_str: roomInfo?.room?.id_str ?? "",
                 stream_url: {
-                    pull_datas: roomInfo.room?.stream_url?.pull_datas,
+                    pull_datas: roomInfo?.room?.stream_url?.pull_datas,
                     live_core_sdk_data: {
                         pull_data: {
                             options: { qualities: streamData.H264_streamData?.options?.qualities ?? [] },
@@ -201,30 +303,101 @@ async function getRoomInfoByWeb(webRoomId, opts = {}) {
     });
     assert(res.data.status_code === 0, `Unexpected resp, code ${res.data.status_code}, msg ${JSON.stringify(res.data.data)}, id ${webRoomId}, cookies: ${cookies}`);
     const data = res.data.data;
-    const room = data.data[0];
-    assert(room, `No room data, id ${webRoomId}`);
+    const room = data?.data?.[0];
+    return {
+        living: data?.room_status === 0,
+        nickname: data?.user?.nickname ?? "",
+        avatar: data?.user?.avatar_thumb?.url_list?.[0] ?? "",
+        sec_uid: data?.user?.sec_uid ?? "",
+        api: "web",
+        room: {
+            title: room?.title ?? "",
+            cover: room?.cover?.url_list?.[0] ?? "",
+            id_str: room?.id_str ?? "",
+            stream_url: room?.stream_url,
+        },
+    };
+}
+async function getRoomInfoByMobile(secUserId, opts = {}) {
+    if (!secUserId) {
+        throw new Error("Mobile API need secUserId, please set uid field");
+    }
+    if (typeof secUserId === "number") {
+        throw new Error("Mobile API need secUserId string, please set uid field");
+    }
+    const params = {
+        app_id: 1128,
+        live_id: 1,
+        verifyFp: "",
+        room_id: 2,
+        type_id: 0,
+        sec_user_id: secUserId,
+    };
+    const res = await requester.get(`https://webcast.amemv.com/webcast/room/reflow/info/`, {
+        params,
+        headers: {
+            cookie: opts.auth,
+        },
+    });
+    // @ts-ignore
+    const room = res?.data?.data?.room;
     return {
-        living: data.room_status === 0,
-        nickname: data.user.nickname,
-        avatar: data?.user?.avatar_thumb?.url_list?.[0],
+        living: room?.status === 2,
+        nickname: room?.owner?.nickname,
+        sec_uid: room?.owner?.sec_uid,
+        avatar: room?.owner?.avatar_thumb?.url_list?.[0],
+        api: "mobile",
         room: {
-            title: room.title,
-            cover: room.cover?.url_list?.[0],
-            id_str: room.id_str,
-            stream_url: room.stream_url,
+            title: room?.title,
+            cover: room?.cover?.url_list?.[0],
+            id_str: room?.id_str,
+            stream_url: room?.stream_url,
         },
     };
 }
 export async function getRoomInfo(webRoomId, opts = {}) {
     let data;
-    if (opts.api === "webHTML") {
+    let api = opts.api ?? "web";
+    // 如果选择了 random，则随机选择一个可用的接口
+    if (api === "random") {
+        api = selectRandomAPI();
+    }
+    if (api === "mobile" || api === "userHTML") {
+        // mobile 接口需要 sec_uid 参数，老数据可能没有，实现兼容
+        if (!opts.uid || typeof opts.uid !== "string") {
+            api = "web";
+        }
+    }
+    if (api === "webHTML") {
         data = await getRoomInfoByHtml(webRoomId, opts);
     }
+    else if (api === "mobile") {
+        data = await getRoomInfoByMobile(opts.uid, opts);
+    }
+    else if (api === "userHTML") {
+        data = await getRoomInfoByUserWeb(opts.uid, opts);
+    }
     else {
         data = await getRoomInfoByWeb(webRoomId, opts);
     }
+    // console.log(JSON.stringify(data, null, 2));
     const room = data.room;
     assert(room, `No room data, id ${webRoomId}`);
+    if (api === "userHTML") {
+        return {
+            living: data.living,
+            roomId: webRoomId,
+            owner: data.nickname,
+            title: room?.title ?? data.nickname,
+            streams: [],
+            sources: [],
+            avatar: data.avatar,
+            cover: room.cover,
+            liveId: room.id_str,
+            uid: data.sec_uid,
+            api: data.api,
+        };
+    }
     if (room?.stream_url == null) {
         return {
             living: false,
@@ -236,6 +409,8 @@ export async function getRoomInfo(webRoomId, opts = {}) {
             avatar: data.avatar,
             cover: room.cover,
             liveId: room.id_str,
+            uid: data.sec_uid,
+            api: data.api,
         };
     }
     let qualities = [];
@@ -314,12 +489,20 @@ export async function getRoomInfo(webRoomId, opts = {}) {
         avatar: data.avatar,
         cover: room.cover,
         liveId: room.id_str,
+        uid: data.sec_uid,
+        api: data.api,
     };
 }
+let nonceCache;
 /**
  * 获取nonce
  */
 async function getNonce(url) {
+    const now = new Date().getTime();
+    // 缓存6小时
+    if (nonceCache?.startTimestamp && now - nonceCache.startTimestamp < 6 * 60 * 60 * 1000) {
+        return nonceCache.nonce;
+    }
     const res = await requester.get(url);
     if (!res.headers["set-cookie"]) {
         throw new Error("No cookie in response");
@@ -332,7 +515,14 @@ async function getNonce(url) {
             return;
         cookies[keyPart.trim()] = valuePart.trim();
     });
-    return cookies["__ac_nonce"];
+    const nonce = cookies["__ac_nonce"];
+    if (nonce) {
+        nonceCache = {
+            startTimestamp: now,
+            nonce: nonce,
+        };
+    }
+    return nonce;
 }
 /**
  * 解析抖音号

package/lib/index.js

@@ -31,7 +31,7 @@ function createRecorder(opts) {
             const channelId = this.channelId;
             const info = await getInfo(channelId, {
                 cookie: this.auth,
-                api: this.api,
+                uid: this.uid,
             });
             return {
                 channelId,
@@ -80,13 +80,20 @@ const ffmpegInputOptions = [
 const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isManualStart, }) {
     if (this.recordHandle != null)
         return this.recordHandle;
-    const liveInfo = await getInfo(this.channelId, {
-        cookie: this.auth,
-        api: this.api,
-    });
-    const { living, owner, title } = liveInfo;
-    this.liveInfo = liveInfo;
-    if (liveInfo.liveId === banLiveId) {
+    try {
+        const liveInfo = await getInfo(this.channelId, {
+            cookie: this.auth,
+            api: this.api,
+            uid: this.uid,
+        });
+        this.liveInfo = liveInfo;
+        this.state = "idle";
+    }
+    catch (error) {
+        this.state = "check-error";
+        throw error;
+    }
+    if (this.liveInfo.liveId && this.liveInfo.liveId === banLiveId) {
         this.tempStopIntervalCheck = true;
     }
     else {
@@ -94,7 +101,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
     }
     if (this.tempStopIntervalCheck)
         return null;
-    if (!living)
+    if (!this.liveInfo.living)
         return null;
     let res;
     try {
@@ -108,6 +115,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         if (isManualStart) {
             strictQuality = false;
         }
+        // TODO: 检查mobile接口处理双屏录播流
         res = await getStream({
             channelId: this.channelId,
             quality: this.quality,
@@ -118,14 +126,22 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
             formatPriorities: this.formatPriorities,
             doubleScreen: this.doubleScreen,
             api: this.api,
+            uid: this.uid,
         });
+        this.liveInfo.owner = res.owner;
+        this.liveInfo.title = res.title;
+        this.liveInfo.cover = res.cover;
+        this.liveInfo.liveId = res.liveId;
+        this.liveInfo.avatar = res.avatar;
+        this.liveInfo.startTime = new Date();
     }
     catch (err) {
         if (this.qualityRetry > 0)
             this.qualityRetry -= 1;
-        this.state = "idle";
+        this.state = "check-error";
         throw err;
     }
+    const { owner, title } = this.liveInfo;
     this.state = "recording";
     const { currentStream: stream, sources: availableSources, streams: availableStreams } = res;
     this.availableStreams = availableStreams.map((s) => s.desc);
@@ -150,7 +166,6 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         this.recordHandle?.stop(reason);
     };
     let recorderType = this.recorderType === "mesio" ? "mesio" : "ffmpeg";
-    // TODO:测试只录制音频，hls以及fmp4
     const recorder = createBaseRecorder(recorderType, {
         url: stream.url,
         outputOptions: ffmpegOutputOptions,
@@ -208,7 +223,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, banLiveId, isMan
         }
         this.emit("progress", progress);
     });
-    const client = new DouYinDanmaClient(liveInfo.liveId, {
+    const client = new DouYinDanmaClient(this?.liveInfo?.liveId, {
         cookie: this.auth,
     });
     client.on("chat", (msg) => {
@@ -389,6 +404,7 @@ export const provider = {
             title: info.title,
             owner: info.owner,
             avatar: info.avatar,
+            uid: info.uid,
         };
     },
     createRecorder(opts) {

package/lib/loadBalancer/example.d.ts

@@ -0,0 +1,2 @@
+declare function runExamples(): Promise<void>;
+export { runExamples };

package/lib/loadBalancer/example.js

@@ -0,0 +1,130 @@
+/**
+ * 抖音录播器负载均衡使用示例
+ */
+import { getInfo } from "../stream.js";
+import { loadBalancer } from "./loadBalancerManager.js";
+async function basicExample() {
+    console.log("=== 基本使用示例 ===");
+    try {
+        // 使用负载均衡模式获取房间信息
+        const roomInfo = await getInfo("测试房间ID", {
+            api: "balance", // 关键：使用balance模式启用负载均衡
+            cookie: "your-cookie-here",
+        });
+        console.log("获取到房间信息:", {
+            title: roomInfo.title,
+            owner: roomInfo.owner,
+            living: roomInfo.living,
+        });
+    }
+    catch (error) {
+        console.error("获取房间信息失败:", error.message);
+    }
+}
+async function managementExample() {
+    console.log("\n=== 管理功能示例 ===");
+    // 1. 查看当前状态
+    console.log("1. 当前负载均衡器状态:");
+    loadBalancer.printStatus();
+    // 2. 检查API健康状态
+    console.log("\n2. API健康状态检查:");
+    const apis = ["web", "webHTML", "mobile", "userHTML"];
+    apis.forEach((api) => {
+        const isHealthy = loadBalancer.isAPIHealthy(api);
+        console.log(`${api}: ${isHealthy ? "✅ 健康" : "❌ 不健康"}`);
+    });
+    // 3. 获取推荐API
+    const recommendedAPI = loadBalancer.getRecommendedAPI();
+    console.log(`\n3. 推荐使用的API: ${recommendedAPI}`);
+    // 4. 配置调整示例
+    console.log("\n4. 配置调整示例:");
+    console.log("原始配置:", loadBalancer.getConfig());
+    // 调整配置：更保守的失败策略
+    loadBalancer.updateConfig({
+        maxFailures: 2, // 减少到2次失败就禁用
+        blockDuration: 120000, // 禁用2分钟
+    });
+    console.log("调整后配置:", loadBalancer.getConfig());
+    // 5. API权重调整示例
+    console.log("\n5. API权重调整示例:");
+    console.log("调整前状态:");
+    console.table(loadBalancer.getStatus());
+    // 提高mobile接口的优先级和权重
+    loadBalancer.updateAPIConfig("mobile", {
+        priority: 1, // 最高优先级
+        weight: 5, // 最高权重
+    });
+    console.log("调整mobile接口权重后:");
+    console.table(loadBalancer.getStatus());
+}
+async function errorHandlingExample() {
+    console.log("\n=== 错误处理示例 ===");
+    // 模拟检查被禁用的API
+    const blockedAPIs = loadBalancer.getBlockedAPIs();
+    if (blockedAPIs.length > 0) {
+        console.log(`发现 ${blockedAPIs.length} 个被禁用的API:`, blockedAPIs);
+        // 可以选择重置这些API
+        console.log("重置被禁用的API...");
+        blockedAPIs.forEach((api) => {
+            loadBalancer.resetAPI(api);
+        });
+        console.log("重置完成，当前健康的API:", loadBalancer.getHealthyAPIs());
+    }
+    else {
+        console.log("所有API都处于健康状态 ✅");
+    }
+}
+async function monitoringExample() {
+    console.log("\n=== 监控示例 ===");
+    // 模拟监控函数
+    function checkSystemHealth() {
+        const status = loadBalancer.getStatus();
+        const healthyCount = status.filter((s) => !s.isBlocked).length;
+        const totalCount = status.length;
+        console.log(`系统健康状态: ${healthyCount}/${totalCount} 个API可用`);
+        if (healthyCount < totalCount / 2) {
+            console.warn("⚠️  警告：超过一半的API不可用！");
+            loadBalancer.printStatus();
+            // 可以触发告警或自动恢复逻辑
+            console.log("执行自动恢复...");
+            loadBalancer.resetAll();
+        }
+        // 显示详细状态
+        status.forEach((s) => {
+            if (s.isBlocked) {
+                const retryTime = new Date(s.nextRetryTime).toLocaleString();
+                console.log(`❌ ${s.api}: 被禁用，下次重试时间: ${retryTime}`);
+            }
+            else if (s.failureCount > 0) {
+                console.log(`⚠️  ${s.api}: 失败 ${s.failureCount} 次，仍可用`);
+            }
+            else {
+                console.log(`✅ ${s.api}: 健康`);
+            }
+        });
+    }
+    // 执行健康检查
+    checkSystemHealth();
+    // 在实际应用中，可以设置定时器
+    // setInterval(checkSystemHealth, 60000); // 每分钟检查一次
+}
+// 主函数
+async function runExamples() {
+    try {
+        await basicExample();
+        await managementExample();
+        await errorHandlingExample();
+        await monitoringExample();
+        console.log("\n=== 示例执行完成 ===");
+        console.log("\n最终状态:");
+        loadBalancer.printStatus();
+    }
+    catch (error) {
+        console.error("示例执行失败:", error);
+    }
+}
+// 如果直接运行此文件
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runExamples();
+}
+export { runExamples };

package/lib/loadBalancer/loadBalancer.d.ts

@@ -0,0 +1,71 @@
+import type { APIType, APIEndpoint, APIEndpointStatus, LoadBalancerConfig } from "../types.js";
+/**
+ * API 负载均衡器类
+ * 实现多个 API 接口的负载均衡调用，具备失败重试和禁用机制
+ */
+export declare class APILoadBalancer {
+    private endpoints;
+    private config;
+    constructor(config?: Partial<LoadBalancerConfig>);
+    /**
+     * 初始化 API 端点配置
+     */
+    private initializeEndpoints;
+    /**
+     * 获取下一个可用的 API 端点
+     * 使用加权轮询算法，优先选择权重高且未被禁用的端点
+     */
+    private getNextEndpoint;
+    /**
+     * 记录 API 调用失败
+     */
+    private recordFailure;
+    /**
+     * 记录 API 调用成功
+     */
+    private recordSuccess;
+    /**
+     * 使用负载均衡策略调用 getRoomInfo
+     */
+    callWithLoadBalance(webRoomId: string, opts?: {
+        auth?: string;
+        doubleScreen?: boolean;
+        uid?: string | number;
+    }): Promise<{
+        living: boolean;
+        roomId: string;
+        owner: string;
+        title: string;
+        streams: any[];
+        sources: any[];
+        avatar: string;
+        cover: string;
+        liveId: string;
+        uid: string;
+    }>;
+    /**
+     * 获取当前端点状态（用于调试和监控）
+     */
+    getEndpointStatus(): APIEndpointStatus[];
+    /**
+     * 手动重置某个端点的状态
+     */
+    resetEndpoint(apiType: APIType): void;
+    /**
+     * 重置所有端点状态
+     */
+    resetAllEndpoints(): void;
+    /**
+     * 更新端点配置
+     */
+    updateEndpointConfig(apiType: APIType, updates: Partial<APIEndpoint>): void;
+    /**
+     * 获取负载均衡器配置
+     */
+    getConfig(): LoadBalancerConfig;
+    /**
+     * 更新负载均衡器配置
+     */
+    updateConfig(updates: Partial<LoadBalancerConfig>): void;
+}
+export declare const globalLoadBalancer: APILoadBalancer;

package/lib/loadBalancer/loadBalancer.js

@@ -0,0 +1,196 @@
+import { getRoomInfo } from "../douyin_api.js";
+/**
+ * API 负载均衡器类
+ * 实现多个 API 接口的负载均衡调用，具备失败重试和禁用机制
+ */
+export class APILoadBalancer {
+    endpoints = [];
+    config;
+    constructor(config) {
+        this.config = {
+            maxFailures: 3, // 连续失败3次后禁用
+            blockDuration: 3 * 60 * 1000, // 禁用3分钟
+            retryMultiplier: 1.5, // 重试时间倍增
+            healthCheckInterval: 30 * 1000, // 30秒健康检查
+            ...config,
+        };
+        // 初始化可用的 API 端点
+        this.initializeEndpoints();
+    }
+    /**
+     * 初始化 API 端点配置
+     */
+    initializeEndpoints() {
+        const defaultEndpoints = [
+            { name: "web", priority: 2, weight: 1 },
+            { name: "webHTML", priority: 1, weight: 1 },
+            { name: "mobile", priority: 6, weight: 1 },
+            { name: "userHTML", priority: 4, weight: 1 },
+        ];
+        this.endpoints = defaultEndpoints.map((endpoint) => ({
+            endpoint,
+            failureCount: 0,
+            lastFailureTime: 0,
+            isBlocked: false,
+            nextRetryTime: 0,
+        }));
+    }
+    /**
+     * 获取下一个可用的 API 端点
+     * 使用加权轮询算法，优先选择权重高且未被禁用的端点
+     */
+    getNextEndpoint() {
+        const now = Date.now();
+        // 清理过期的禁用状态
+        this.endpoints.forEach((status) => {
+            if (status.isBlocked && now >= status.nextRetryTime) {
+                status.isBlocked = false;
+                status.failureCount = Math.max(0, status.failureCount - 1); // 部分恢复
+            }
+        });
+        // 获取可用的端点
+        const availableEndpoints = this.endpoints.filter((status) => !status.isBlocked);
+        if (availableEndpoints.length === 0) {
+            return null; // 所有端点都被禁用
+        }
+        // 按优先级和权重排序
+        availableEndpoints.sort((a, b) => {
+            if (a.endpoint.priority !== b.endpoint.priority) {
+                return a.endpoint.priority - b.endpoint.priority; // 优先级越小越好
+            }
+            return b.endpoint.weight - a.endpoint.weight; // 权重越大越好
+        });
+        // 使用加权随机选择
+        const totalWeight = availableEndpoints.reduce((sum, status) => sum + status.endpoint.weight, 0);
+        const random = Math.random() * totalWeight;
+        let currentWeight = 0;
+        for (const status of availableEndpoints) {
+            currentWeight += status.endpoint.weight;
+            if (random <= currentWeight) {
+                return status;
+            }
+        }
+        // 如果加权选择失败，返回第一个可用的
+        return availableEndpoints[0];
+    }
+    /**
+     * 记录 API 调用失败
+     */
+    recordFailure(apiType, error) {
+        const status = this.endpoints.find((s) => s.endpoint.name === apiType);
+        if (!status)
+            return;
+        status.failureCount++;
+        status.lastFailureTime = Date.now();
+        // 如果失败次数超过阈值，禁用该端点
+        if (status.failureCount >= this.config.maxFailures) {
+            status.isBlocked = true;
+            const blockDuration = this.config.blockDuration *
+                Math.pow(this.config.retryMultiplier, status.failureCount - this.config.maxFailures);
+            status.nextRetryTime = Date.now() + blockDuration;
+            console.warn(`API ${apiType} has been blocked due to ${status.failureCount} failures. Next retry at: ${(new Date(status.nextRetryTime).toISOString(), error.message)}`);
+        }
+    }
+    /**
+     * 记录 API 调用成功
+     */
+    recordSuccess(apiType) {
+        const status = this.endpoints.find((s) => s.endpoint.name === apiType);
+        if (!status)
+            return;
+        // 成功调用后，减少失败计数
+        if (status.failureCount > 0) {
+            status.failureCount = Math.max(0, status.failureCount - 1);
+        }
+        // 如果之前被禁用，现在可以恢复
+        if (status.isBlocked && status.failureCount === 0) {
+            status.isBlocked = false;
+            status.nextRetryTime = 0;
+        }
+    }
+    /**
+     * 使用负载均衡策略调用 getRoomInfo
+     */
+    async callWithLoadBalance(webRoomId, opts = {}) {
+        const maxAttempts = this.endpoints.length;
+        let lastError = null;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const endpointStatus = this.getNextEndpoint();
+            if (!endpointStatus) {
+                throw new Error("所有 API 端点都不可用，请稍后重试");
+            }
+            const apiType = endpointStatus.endpoint.name;
+            try {
+                const result = await getRoomInfo(webRoomId, {
+                    ...opts,
+                    api: apiType,
+                });
+                // 调用成功，记录成功状态
+                this.recordSuccess(apiType);
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                this.recordFailure(apiType, lastError);
+                console.warn(`API ${apiType} failed (attempt ${attempt + 1}/${maxAttempts}):`, lastError.message);
+                // 如果这是最后一次尝试，或者没有更多可用端点，则抛出错误
+                if (attempt === maxAttempts - 1) {
+                    break;
+                }
+            }
+        }
+        throw new Error(`所有 API 调用都失败了。最后一个错误: ${lastError?.message || "未知错误"}`);
+    }
+    /**
+     * 获取当前端点状态（用于调试和监控）
+     */
+    getEndpointStatus() {
+        return this.endpoints.map((status) => ({ ...status }));
+    }
+    /**
+     * 手动重置某个端点的状态
+     */
+    resetEndpoint(apiType) {
+        const status = this.endpoints.find((s) => s.endpoint.name === apiType);
+        if (status) {
+            status.failureCount = 0;
+            status.lastFailureTime = 0;
+            status.isBlocked = false;
+            status.nextRetryTime = 0;
+        }
+    }
+    /**
+     * 重置所有端点状态
+     */
+    resetAllEndpoints() {
+        this.endpoints.forEach((status) => {
+            status.failureCount = 0;
+            status.lastFailureTime = 0;
+            status.isBlocked = false;
+            status.nextRetryTime = 0;
+        });
+    }
+    /**
+     * 更新端点配置
+     */
+    updateEndpointConfig(apiType, updates) {
+        const status = this.endpoints.find((s) => s.endpoint.name === apiType);
+        if (status) {
+            Object.assign(status.endpoint, updates);
+        }
+    }
+    /**
+     * 获取负载均衡器配置
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * 更新负载均衡器配置
+     */
+    updateConfig(updates) {
+        Object.assign(this.config, updates);
+    }
+}
+// 创建全局单例实例
+export const globalLoadBalancer = new APILoadBalancer();

package/lib/loadBalancer/loadBalancerManager.d.ts

@@ -0,0 +1,75 @@
+import type { APIType, LoadBalancerConfig } from "../types.js";
+/**
+ * 负载均衡器管理工具类
+ * 提供简化的接口来管理和配置负载均衡器
+ */
+export declare class LoadBalancerManager {
+    /**
+     * 获取所有端点的当前状态
+     */
+    static getStatus(): {
+        api: APIType;
+        priority: number;
+        weight: number;
+        failureCount: number;
+        isBlocked: boolean;
+        lastFailureTime: string;
+        nextRetryTime: string;
+    }[];
+    /**
+     * 重置指定 API 的状态
+     */
+    static resetAPI(apiType: APIType): void;
+    /**
+     * 重置所有 API 的状态
+     */
+    static resetAll(): void;
+    /**
+     * 更新 API 端点的配置
+     */
+    static updateAPIConfig(apiType: APIType, config: {
+        priority?: number;
+        weight?: number;
+    }): void;
+    /**
+     * 获取负载均衡器配置
+     */
+    static getConfig(): LoadBalancerConfig;
+    /**
+     * 更新负载均衡器配置
+     */
+    static updateConfig(config: Partial<LoadBalancerConfig>): void;
+    /**
+     * 获取健康的（未被禁用的）API 列表
+     */
+    static getHealthyAPIs(): APIType[];
+    /**
+     * 获取被禁用的 API 列表
+     */
+    static getBlockedAPIs(): APIType[];
+    /**
+     * 检查特定 API 是否可用
+     */
+    static isAPIHealthy(apiType: APIType): boolean;
+    /**
+     * 获取推荐使用的 API（基于当前状态和权重）
+     */
+    static getRecommendedAPI(): APIType | null;
+    /**
+     * 打印当前负载均衡器状态（用于调试）
+     */
+    static printStatus(): void;
+}
+export declare const loadBalancer: {
+    getStatus: typeof LoadBalancerManager.getStatus;
+    resetAPI: typeof LoadBalancerManager.resetAPI;
+    resetAll: typeof LoadBalancerManager.resetAll;
+    updateAPIConfig: typeof LoadBalancerManager.updateAPIConfig;
+    getConfig: typeof LoadBalancerManager.getConfig;
+    updateConfig: typeof LoadBalancerManager.updateConfig;
+    getHealthyAPIs: typeof LoadBalancerManager.getHealthyAPIs;
+    getBlockedAPIs: typeof LoadBalancerManager.getBlockedAPIs;
+    isAPIHealthy: typeof LoadBalancerManager.isAPIHealthy;
+    getRecommendedAPI: typeof LoadBalancerManager.getRecommendedAPI;
+    printStatus: typeof LoadBalancerManager.printStatus;
+};

package/lib/loadBalancer/loadBalancerManager.js

@@ -0,0 +1,127 @@
+import { globalLoadBalancer } from "./loadBalancer.js";
+/**
+ * 负载均衡器管理工具类
+ * 提供简化的接口来管理和配置负载均衡器
+ */
+export class LoadBalancerManager {
+    /**
+     * 获取所有端点的当前状态
+     */
+    static getStatus() {
+        return globalLoadBalancer.getEndpointStatus().map((status) => ({
+            api: status.endpoint.name,
+            priority: status.endpoint.priority,
+            weight: status.endpoint.weight,
+            failureCount: status.failureCount,
+            isBlocked: status.isBlocked,
+            lastFailureTime: status.lastFailureTime
+                ? new Date(status.lastFailureTime).toISOString()
+                : null,
+            nextRetryTime: status.nextRetryTime ? new Date(status.nextRetryTime).toISOString() : null,
+        }));
+    }
+    /**
+     * 重置指定 API 的状态
+     */
+    static resetAPI(apiType) {
+        if (apiType === "balance") {
+            throw new Error("Cannot reset 'balance' type. Use resetAll() instead.");
+        }
+        globalLoadBalancer.resetEndpoint(apiType);
+    }
+    /**
+     * 重置所有 API 的状态
+     */
+    static resetAll() {
+        globalLoadBalancer.resetAllEndpoints();
+    }
+    /**
+     * 更新 API 端点的配置
+     */
+    static updateAPIConfig(apiType, config) {
+        if (apiType === "balance") {
+            throw new Error("Cannot update 'balance' type configuration.");
+        }
+        globalLoadBalancer.updateEndpointConfig(apiType, config);
+    }
+    /**
+     * 获取负载均衡器配置
+     */
+    static getConfig() {
+        return globalLoadBalancer.getConfig();
+    }
+    /**
+     * 更新负载均衡器配置
+     */
+    static updateConfig(config) {
+        globalLoadBalancer.updateConfig(config);
+    }
+    /**
+     * 获取健康的（未被禁用的）API 列表
+     */
+    static getHealthyAPIs() {
+        return globalLoadBalancer
+            .getEndpointStatus()
+            .filter((status) => !status.isBlocked)
+            .map((status) => status.endpoint.name);
+    }
+    /**
+     * 获取被禁用的 API 列表
+     */
+    static getBlockedAPIs() {
+        return globalLoadBalancer
+            .getEndpointStatus()
+            .filter((status) => status.isBlocked)
+            .map((status) => status.endpoint.name);
+    }
+    /**
+     * 检查特定 API 是否可用
+     */
+    static isAPIHealthy(apiType) {
+        if (apiType === "balance")
+            return true; // balance 类型总是可用的
+        const status = globalLoadBalancer.getEndpointStatus().find((s) => s.endpoint.name === apiType);
+        return status ? !status.isBlocked : false;
+    }
+    /**
+     * 获取推荐使用的 API（基于当前状态和权重）
+     */
+    static getRecommendedAPI() {
+        const healthyEndpoints = globalLoadBalancer
+            .getEndpointStatus()
+            .filter((status) => !status.isBlocked)
+            .sort((a, b) => {
+            if (a.endpoint.priority !== b.endpoint.priority) {
+                return a.endpoint.priority - b.endpoint.priority;
+            }
+            return b.endpoint.weight - a.endpoint.weight;
+        });
+        return healthyEndpoints.length > 0 ? healthyEndpoints[0].endpoint.name : null;
+    }
+    /**
+     * 打印当前负载均衡器状态（用于调试）
+     */
+    static printStatus() {
+        console.log("=== 负载均衡器状态 ===");
+        console.log("配置:", LoadBalancerManager.getConfig());
+        console.log("端点状态:");
+        console.table(LoadBalancerManager.getStatus());
+        console.log("健康的 APIs:", LoadBalancerManager.getHealthyAPIs());
+        console.log("被禁用的 APIs:", LoadBalancerManager.getBlockedAPIs());
+        console.log("推荐 API:", LoadBalancerManager.getRecommendedAPI());
+    }
+}
+// 暴露简化的管理函数
+export const loadBalancer = {
+    getStatus: LoadBalancerManager.getStatus,
+    resetAPI: LoadBalancerManager.resetAPI,
+    resetAll: LoadBalancerManager.resetAll,
+    updateAPIConfig: LoadBalancerManager.updateAPIConfig,
+    getConfig: LoadBalancerManager.getConfig,
+    updateConfig: LoadBalancerManager.updateConfig,
+    getHealthyAPIs: LoadBalancerManager.getHealthyAPIs,
+    getBlockedAPIs: LoadBalancerManager.getBlockedAPIs,
+    isAPIHealthy: LoadBalancerManager.isAPIHealthy,
+    getRecommendedAPI: LoadBalancerManager.getRecommendedAPI,
+    printStatus: LoadBalancerManager.printStatus,
+};

package/lib/stream.d.ts

@@ -1,7 +1,9 @@
 import type { Recorder } from "@bililive-tools/manager";
+import type { APIType, RealAPIType } from "./types.js";
 export declare function getInfo(channelId: string, opts?: {
     cookie?: string;
-    api?: "web" | "webHTML";
+    api?: APIType;
+    uid?: string | number;
 }): Promise<{
     living: boolean;
     owner: string;
@@ -11,6 +13,8 @@ export declare function getInfo(channelId: string, opts?: {
     cover: string;
     startTime: Date;
     liveId: string;
+    uid: string;
+    api: RealAPIType;
 }>;
 export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" | "streamPriorities" | "sourcePriorities"> & {
     rejectCache?: boolean;
@@ -18,7 +22,8 @@ export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" |
     cookie?: string;
     formatPriorities?: Array<"flv" | "hls">;
     doubleScreen?: boolean;
-    api?: "web" | "webHTML";
+    api?: APIType;
+    uid?: string | number;
 }): Promise<{
     currentStream: {
         name: string;
@@ -34,4 +39,6 @@ export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" |
     avatar: string;
     cover: string;
     liveId: string;
+    uid: string;
+    api: RealAPIType;
 }>;

package/lib/stream.js

@@ -1,6 +1,17 @@
 import { getRoomInfo } from "./douyin_api.js";
+import { globalLoadBalancer } from "./loadBalancer/loadBalancer.js";
 export async function getInfo(channelId, opts) {
-    const info = await getRoomInfo(channelId, opts ?? {});
+    let info;
+    // 如果使用 balance 模式，使用负载均衡器
+    if (opts?.api === "balance") {
+        info = await globalLoadBalancer.callWithLoadBalance(channelId, {
+            auth: opts.cookie,
+            uid: opts.uid,
+        });
+    }
+    else {
+        info = await getRoomInfo(channelId, opts ?? {});
+    }
     return {
         living: info.living,
         owner: info.owner,
@@ -10,13 +21,21 @@ export async function getInfo(channelId, opts) {
         cover: info.cover,
         startTime: new Date(),
         liveId: info.liveId,
+        uid: info.uid,
+        api: info.api,
     };
 }
 export async function getStream(opts) {
+    let api = opts.api ?? "web";
+    if (api === "userHTML") {
+        // userHTML 接口只能用于状态检测
+        api = "web";
+    }
     const info = await getRoomInfo(opts.channelId, {
         doubleScreen: opts.doubleScreen ?? true,
         auth: opts.cookie,
-        api: opts.api ?? "web",
+        api: api,
+        uid: opts.uid,
     });
     if (!info.living) {
         throw new Error("It must be called getStream when living");

package/lib/types.d.ts

@@ -0,0 +1,33 @@
+export type APIType = "web" | "webHTML" | "mobile" | "userHTML" | "balance" | "random";
+export type RealAPIType = Exclude<APIType, "balance" | "random">;
+export interface APIEndpoint {
+    name: APIType;
+    priority: number;
+    weight: number;
+}
+export interface APIEndpointStatus {
+    endpoint: APIEndpoint;
+    failureCount: number;
+    lastFailureTime: number;
+    isBlocked: boolean;
+    nextRetryTime: number;
+}
+export interface LoadBalancerConfig {
+    maxFailures: number;
+    blockDuration: number;
+    retryMultiplier: number;
+    healthCheckInterval: number;
+}
+export interface RoomInfo {
+    living: boolean;
+    nickname: string;
+    sec_uid: string;
+    avatar: string;
+    api: RealAPIType;
+    room: {
+        title: string;
+        cover: string;
+        id_str: string;
+        stream_url: any | null;
+    } | null;
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/douyin-recorder",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "@bililive-tools douyin recorder implemention",
   "main": "./lib/index.js",
   "type": "module",
@@ -38,8 +38,8 @@
     "lodash-es": "^4.17.21",
     "mitt": "^3.0.1",
     "sm-crypto": "^0.3.13",
-    "douyin-danma-listener": "0.2.0",
-    "@bililive-tools/manager": "^1.6.0"
+    "@bililive-tools/manager": "^1.6.1",
+    "douyin-danma-listener": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "*"