@bililive-tools/douyin-recorder 1.5.3 → 1.7.0

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,5 +1,10 @@
 import type { Recorder } from "@bililive-tools/manager";
-export declare function getInfo(channelId: string): Promise<{
+import type { APIType, RealAPIType } from "./types.js";
+export declare function getInfo(channelId: string, opts?: {
+    cookie?: string;
+    api?: APIType;
+    uid?: string | number;
+}): Promise<{
     living: boolean;
     owner: string;
     title: string;
@@ -8,6 +13,8 @@ export declare function getInfo(channelId: string): Promise<{
     cover: string;
     startTime: Date;
     liveId: string;
+    uid: string;
+    api: RealAPIType;
 }>;
 export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" | "streamPriorities" | "sourcePriorities"> & {
     rejectCache?: boolean;
@@ -15,6 +22,8 @@ export declare function getStream(opts: Pick<Recorder, "channelId" | "quality" |
     cookie?: string;
     formatPriorities?: Array<"flv" | "hls">;
     doubleScreen?: boolean;
+    api?: APIType;
+    uid?: string | number;
 }): Promise<{
     currentStream: {
         name: string;
@@ -30,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";
-export async function getInfo(channelId) {
-    const info = await getRoomInfo(channelId);
+import { globalLoadBalancer } from "./loadBalancer/loadBalancer.js";
+export async function getInfo(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) {
         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, {
-        retryOnSpecialCode: true,
         doubleScreen: opts.doubleScreen ?? true,
         auth: opts.cookie,
+        api: api,
+        uid: opts.uid,
     });
     if (!info.living) {
         throw new Error("It must be called getStream when living");