@bililive-tools/manager 1.13.0 → 1.14.1

package/README.md

@@ -12,12 +12,13 @@
 
 ## 支持的平台
 
-| 平台 | 包名                                |
-| ---- | ----------------------------------- |
-| B站  | `@bililive-tools/bilibili-recorder` |
-| 斗鱼 | `@bililive-tools/douyu-recorder`    |
-| 虎牙 | `@bililive-tools/huya-recorder`     |
-| 抖音 | `@bililive-tools/douyin-recorder`   |
+| 平台   | 包名                                |
+| ------ | ----------------------------------- |
+| B站    | `@bililive-tools/bilibili-recorder` |
+| 斗鱼   | `@bililive-tools/douyu-recorder`    |
+| 虎牙   | `@bililive-tools/huya-recorder`     |
+| 抖音   | `@bililive-tools/douyin-recorder`   |
+| 小红书 | `@bililive-tools/xhs-recorder`      |
 
 # 使用
 
@@ -32,9 +33,17 @@ const manager = createRecorderManager({
   savePathRule: "D:\\录制\\{platforme}}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}", // 保存路径，占位符见文档，支持 [ejs](https://ejs.co/) 模板引擎
   autoCheckInterval: 1000 * 60, // 自动检查间隔，单位秒
   maxThreadCount: 3, // 检查并发数
-  waitTime: 0, // 检查后等待时间
+  waitTime: 0, // 检查后等待时间，单位毫秒
   autoRemoveSystemReservedChars: true, // 移除系统非法字符串
   biliBatchQuery: false, // B站检查使用批量接口
+  providerCheckConfig: {
+    // Bilibili 配置：高频检查，更多线程
+    Bilibili: {
+      autoCheckInterval: 5000, // 5秒检查一次
+      maxThreadCount: 5, // 最多5个并发线程
+      waitTime: 500, // 每次检查间隔0.5秒
+    },
+  },
 });
 
 // 不同provider支持的参数不尽相同，具体见相关文档

package/lib/manager.d.ts

@@ -4,6 +4,14 @@ import { RecorderCache } from "./cache.js";
 import { RecorderCreateOpts, Recorder, SerializedRecorder, RecordHandle, DebugLog, Progress } from "./recorder.js";
 import { AnyObject, UnknownObject } from "./utils.js";
 import { StreamManager } from "./downloader/streamManager.js";
+export interface ProviderCheckConfig {
+    /** 检查循环间隔（毫秒） */
+    autoCheckInterval?: number;
+    /** 最大并发检查线程数 */
+    maxThreadCount?: number;
+    /** 每次检查之间的等待时间（毫秒） */
+    waitTime?: number;
+}
 export interface RecorderProvider<E extends AnyObject> {
     id: string;
     name: string;
@@ -20,7 +28,7 @@ export interface RecorderProvider<E extends AnyObject> {
     fromJSON: <T extends SerializedRecorder<E>>(this: RecorderProvider<E>, json: T) => Recorder<E>;
     setFFMPEGOutputArgs: (this: RecorderProvider<E>, args: string[]) => void;
 }
-declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckInterval", "maxThreadCount", "waitTime", "ffmpegOutputArgs", "biliBatchQuery", "recordRetryImmediately"];
+declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckInterval", "maxThreadCount", "waitTime", "ffmpegOutputArgs", "biliBatchQuery", "recordRetryImmediately", "providerCheckConfig"];
 type ConfigurableProp = (typeof configurableProps)[number];
 export interface RecorderManager<ME extends UnknownObject, P extends RecorderProvider<AnyObject> = RecorderProvider<UnknownObject>, PE extends AnyObject = GetProviderExtra<P>, E extends AnyObject = ME & PE> extends Emitter<{
     error: {
@@ -98,11 +106,17 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     recordRetryImmediately: boolean;
     /** 缓存系统 */
     cache: RecorderCache;
+    /** 每个 provider 的检查配置 */
+    providerCheckConfig: Record<string, ProviderCheckConfig>;
+    /** 获取指定 provider 的检查配置（自动 fallback 到全局配置） */
+    getProviderCheckConfig: (this: RecorderManager<ME, P, PE, E>, providerId: string) => Required<ProviderCheckConfig>;
 }
 export type RecorderManagerCreateOpts<ME extends AnyObject = UnknownObject, P extends RecorderProvider<AnyObject> = RecorderProvider<UnknownObject>, PE extends AnyObject = GetProviderExtra<P>, E extends AnyObject = ME & PE> = Partial<Pick<RecorderManager<ME, P, PE, E>, ConfigurableProp>> & {
     providers: P[];
     /** 自定义缓存实现，不提供则使用默认的内存缓存 */
     cache?: RecorderCache;
+    /** 每个 provider 的检查配置，key 为 provider.id */
+    providerCheckConfig?: Record<string, ProviderCheckConfig>;
 };
 export declare function createRecorderManager<ME extends AnyObject = UnknownObject, P extends RecorderProvider<AnyObject> = RecorderProvider<UnknownObject>, PE extends AnyObject = GetProviderExtra<P>, E extends AnyObject = ME & PE>(opts: RecorderManagerCreateOpts<ME, P, PE, E>): RecorderManager<ME, P, PE, E>;
 export declare function genSavePathFromRule<ME extends AnyObject, P extends RecorderProvider<AnyObject>, PE extends AnyObject, E extends AnyObject>(manager: RecorderManager<ME, P, PE, E>, recorder: Recorder<E>, extData: {

package/lib/manager.js

@@ -16,14 +16,16 @@ const configurableProps = [
     "ffmpegOutputArgs",
     "biliBatchQuery",
     "recordRetryImmediately",
+    "providerCheckConfig",
 ];
 function isConfigurableProp(prop) {
     return configurableProps.includes(prop);
 }
 export function createRecorderManager(opts) {
     const recorders = [];
-    let checkLoopTimer;
-    const multiThreadCheck = async (manager) => {
+    // 存储每个 provider 的 timer，key 为 providerId
+    const checkLoopTimers = new Map();
+    const multiThreadCheck = async (manager, providerId) => {
         const handleBatchQuery = async (obj) => {
             for (const recorder of recorders
                 .filter((r) => !r.disableAutoCheck)
@@ -42,15 +44,16 @@ export function createRecorderManager(opts) {
         };
         // 这里暂时不打算用 state == recording 来过滤，provider 必须内部自己处理录制过程中的 check，
         // 这样可以防止一些意外调用 checkLiveStatusAndRecord 时出现重复录制。
-        let needCheckRecorders = recorders
+        const needCheckRecorders = recorders
             .filter((r) => !r.disableAutoCheck)
-            .filter((r) => isBetweenTimeRange(r.handleTime));
-        let threads = [];
-        if (manager.biliBatchQuery) {
-            const biliNeedCheckRecorders = needCheckRecorders
-                .filter((r) => r.providerId === "Bilibili")
-                .filter((r) => r.recordHandle == null);
-            needCheckRecorders = needCheckRecorders.filter((r) => r.providerId !== "Bilibili");
+            .filter((r) => isBetweenTimeRange(r.handleTime))
+            .filter((r) => r.providerId === providerId);
+        const providerConfig = manager.getProviderCheckConfig(providerId);
+        const threads = [];
+        // Bilibili 批量查询特殊处理
+        if (providerId === "Bilibili" && manager.biliBatchQuery) {
+            const biliNeedCheckRecorders = needCheckRecorders.filter((r) => r.recordHandle == null);
+            // const biliRecordingRecorders = needCheckRecorders.filter((r) => r.recordHandle != null);
             const roomIds = biliNeedCheckRecorders.map((r) => r.channelId).map(Number);
             try {
                 if (roomIds.length !== 0) {
@@ -61,9 +64,13 @@ export function createRecorderManager(opts) {
             catch (err) {
                 manager.emit("error", { source: "getBiliStatusInfoByRoomIds", err });
                 // 如果批量查询失败，则使用单个查询
-                needCheckRecorders = needCheckRecorders.concat(biliNeedCheckRecorders);
+                needCheckRecorders.push(...biliNeedCheckRecorders);
             }
+            // 正在录制的也需要检查（放回队列）
+            // needCheckRecorders.length = 0;
+            // needCheckRecorders.push(...biliRecordingRecorders);
         }
+        // 为当前 provider 创建线程池
         const checkOnce = async () => {
             const recorder = needCheckRecorders.shift();
             if (recorder == null)
@@ -76,12 +83,12 @@ export function createRecorderManager(opts) {
                 banLiveId,
             });
         };
-        threads = threads.concat(range(0, manager.maxThreadCount).map(async () => {
+        threads.push(...range(0, providerConfig.maxThreadCount).map(async () => {
             while (needCheckRecorders.length > 0) {
                 try {
                     await checkOnce();
-                    if (manager.waitTime > 0) {
-                        await sleep(manager.waitTime);
+                    if (providerConfig.waitTime > 0) {
+                        await sleep(providerConfig.waitTime);
                     }
                 }
                 catch (err) {
@@ -183,6 +190,7 @@ export function createRecorderManager(opts) {
                 this.emit("RecoderLiveStart", { recorder: recorder });
             });
             this.emit("RecorderAdded", recorder.toJSON());
+            // startCheckLoop 会为所有注册的 provider 启动检查循环，无需在此处额外处理
             return recorder;
         },
         removeRecorder(recorder) {
@@ -241,7 +249,7 @@ export function createRecorderManager(opts) {
             await recorder.recordHandle.cut();
             return recorder;
         },
-        autoCheckInterval: opts.autoCheckInterval ?? 1000,
+        autoCheckInterval: opts.autoCheckInterval ?? 60000,
         maxThreadCount: opts.maxThreadCount ?? 3,
         waitTime: opts.waitTime ?? 0,
         isCheckLoopRunning: false,
@@ -250,30 +258,60 @@ export function createRecorderManager(opts) {
                 return;
             this.isCheckLoopRunning = true;
             // TODO: emit updated event
-            const checkLoop = async () => {
-                try {
-                    await multiThreadCheck(this);
-                }
-                catch (err) {
-                    this.emit("error", { source: "multiThreadCheck", err });
-                }
-                finally {
-                    if (!this.isCheckLoopRunning) {
-                        // do nothing
+            // 为每个 provider 创建独立的检查循环
+            const startProviderCheckLoop = (providerId) => {
+                const providerConfig = this.getProviderCheckConfig(providerId);
+                const checkLoop = async () => {
+                    try {
+                        // 只检查当前 provider 的 recorders
+                        await multiThreadCheck(this, providerId);
                     }
-                    else {
-                        checkLoopTimer = setTimeout(checkLoop, this.autoCheckInterval);
+                    catch (err) {
+                        this.emit("error", { source: "multiThreadCheck", err });
                     }
-                }
+                    finally {
+                        if (!this.isCheckLoopRunning) {
+                            // 停止了，清理 timer
+                            const timer = checkLoopTimers.get(providerId);
+                            if (timer) {
+                                clearTimeout(timer);
+                                checkLoopTimers.delete(providerId);
+                            }
+                        }
+                        else {
+                            // 检查该 provider 是否还有 recorder
+                            const hasRecorders = this.recorders.some((r) => r.providerId === providerId);
+                            if (hasRecorders) {
+                                // 继续循环
+                                const timer = setTimeout(checkLoop, providerConfig.autoCheckInterval);
+                                checkLoopTimers.set(providerId, timer);
+                            }
+                            else {
+                                // 没有 recorder 了，停止该 provider 的检查循环
+                                // TODO: 也许不需要删除定时器
+                                checkLoopTimers.delete(providerId);
+                            }
+                        }
+                    }
+                };
+                void checkLoop();
             };
-            void checkLoop();
+            // 直接从注册的 provider 获取所有 provider IDs
+            const providerIds = this.providers.map((p) => p.id);
+            for (const providerId of providerIds) {
+                startProviderCheckLoop(providerId);
+            }
         },
         stopCheckLoop() {
             if (!this.isCheckLoopRunning)
                 return;
             this.isCheckLoopRunning = false;
             // TODO: emit updated event
-            clearTimeout(checkLoopTimer);
+            // 清理所有 provider 的 timer
+            for (const timer of checkLoopTimers.values()) {
+                clearTimeout(timer);
+            }
+            checkLoopTimers.clear();
         },
         savePathRule: opts.savePathRule ??
             path.join(process.cwd(), "{platform}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}"),
@@ -281,6 +319,15 @@ export function createRecorderManager(opts) {
         biliBatchQuery: opts.biliBatchQuery ?? false,
         recordRetryImmediately: opts.recordRetryImmediately ?? false,
         cache: opts.cache ?? new RecorderCacheImpl(new MemoryCacheStore()),
+        providerCheckConfig: opts.providerCheckConfig ?? {},
+        getProviderCheckConfig(providerId) {
+            const providerConfig = this.providerCheckConfig[providerId];
+            return {
+                autoCheckInterval: providerConfig?.autoCheckInterval ?? this.autoCheckInterval,
+                maxThreadCount: providerConfig?.maxThreadCount ?? this.maxThreadCount,
+                waitTime: providerConfig?.waitTime ?? this.waitTime,
+            };
+        },
         ffmpegOutputArgs: opts.ffmpegOutputArgs ??
             "-c copy" +
                 /**

package/lib/recorder.d.ts

@@ -132,6 +132,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
         cover: string;
         liveId?: string;
         recordStartTime: Date;
+        area?: string;
     };
     tempStopIntervalCheck?: boolean;
     /** 缓存实例（命名空间） */
@@ -152,6 +153,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
         channelId: ChannelId;
         living: boolean;
         liveStartTime: Date;
+        area: string;
     }>;
     getStream: (this: Recorder<E>) => Promise<{
         source: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/manager",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "description": "Batch scheduling recorders",
   "main": "./lib/index.js",
   "type": "module",
@@ -38,7 +38,7 @@
     "mitt": "^3.0.1",
     "string-argv": "^0.3.2",
     "lodash-es": "^4.17.21",
-    "axios": "^1.7.8",
+    "axios": "^1.15.0",
     "fs-extra": "^11.2.0",
     "ejs": "^3.1.10"
   },