@bililive-tools/manager 1.13.0 → 1.16.0

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/downloader/BililiveDownloader.js

@@ -194,6 +194,11 @@ export class BililiveDownloader extends EventEmitter {
         if (timeMatch) {
             time = timeMatch[1];
         }
+        const spaceMath = line.match(/下载进度:\s*([\d.]+\s*MB)\s*/);
+        if (spaceMath) {
+            const space = spaceMath[1];
+            time = time ? `${time} ${space}` : space;
+        }
         return {
             time,
         };

package/lib/downloader/FFmpegDownloader.js

@@ -154,7 +154,7 @@ export class FFmpegDownloader extends EventEmitter {
         let time = null;
         const timeMatch = line.match(/time=([0-9:.]+)/);
         if (timeMatch) {
-            time = timeMatch[1];
+            time = timeMatch[1].split(".")[0];
         }
         return {
             time,

package/lib/downloader/IDownloader.d.ts

@@ -11,6 +11,7 @@ export interface BaseRecorderOptions {
     getSavePath: (data: {
         startTime: number;
         title?: string;
+        extraMs?: boolean;
     }) => string;
     segment: Segment;
     inputOptions?: string[];
@@ -38,6 +39,7 @@ export interface IDownloader extends EventEmitter {
     readonly getSavePath: (data: {
         startTime: number;
         title?: string;
+        extraMs?: boolean;
     }) => string;
     run(): void;
     stop(): Promise<void>;

package/lib/downloader/streamManager.d.ts

@@ -5,6 +5,7 @@ import type { TrueVideoFormat } from "../index.js";
 export type GetSavePath = (data: {
     startTime: number;
     title?: string;
+    extraMs?: boolean;
 }) => string;
 type RecorderType = Exclude<RecorderCreateOpts["recorderType"], undefined | "auto">;
 export declare class Segment extends EventEmitter {

package/lib/downloader/streamManager.js

@@ -1,5 +1,6 @@
 import EventEmitter from "node:events";
 import fs from "fs/promises";
+import fsSync from "fs";
 import { createRecordExtraDataController } from "../xml_stream_controller.js";
 import { ensureFolderExist, isFfmpegStartSegment, isMesioStartSegment, isBililiveStartSegment, isFfmpegStart, retry, cleanTerminalText, } from "../utils.js";
 export class Segment extends EventEmitter {
@@ -64,10 +65,19 @@ export class Segment extends EventEmitter {
                 });
             }
         }
-        this.outputVideoFilePath = this.getSavePath({
+        let recordSavePath = this.getSavePath({
             startTime: startTime,
-            title: liveInfo?.title,
+            title: liveInfo?.title ? liveInfo.title : undefined,
         });
+        // 文件重复判断
+        if (fsSync.existsSync(recordSavePath + "." + this.videoExt)) {
+            recordSavePath = this.getSavePath({
+                startTime: startTime,
+                title: liveInfo?.title,
+                extraMs: true,
+            });
+        }
+        this.outputVideoFilePath = recordSavePath;
         ensureFolderExist(this.outputVideoFilePath);
         if (!this.disableDanma) {
             this.extraDataController = createRecordExtraDataController(`${this.outputVideoFilePath}.xml`);
@@ -112,12 +122,19 @@ export class StreamManager extends EventEmitter {
     callBack;
     constructor(getSavePath, hasSegment, disableDanma, recorderType, videoFormat, callBack) {
         super();
-        const recordSavePath = getSavePath({ startTime: Date.now() });
-        this.recordSavePath = recordSavePath;
+        const startTime = Date.now();
+        let recordSavePath = getSavePath({ startTime });
         this.videoFormat = videoFormat;
         this.recorderType = recorderType;
         this.hasSegment = hasSegment;
         this.callBack = callBack;
+        console.log("Initial recordSavePath:", recordSavePath);
+        // 文件重复判断
+        if (fsSync.existsSync(recordSavePath + "." + videoFormat)) {
+            console.log("File already exists, generating new save path with extraMs");
+            recordSavePath = getSavePath({ startTime, extraMs: true });
+        }
+        this.recordSavePath = recordSavePath;
         if (hasSegment) {
             this.segment = new Segment(getSavePath, disableDanma, this.videoExt);
             this.segment.on("DebugLog", (data) => {
@@ -131,6 +148,7 @@ export class StreamManager extends EventEmitter {
             });
         }
         else {
+            ensureFolderExist(recordSavePath);
             const extraDataSavePath = `${recordSavePath}.xml`;
             if (!disableDanma) {
                 this.extraDataController = createRecordExtraDataController(extraDataSavePath);

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: {
@@ -111,6 +125,7 @@ export declare function genSavePathFromRule<ME extends AnyObject, P extends Reco
     startTime: number;
     liveStartTime: Date;
     recordStartTime: Date;
+    extraMs?: boolean;
 }): string;
 export type GetProviderExtra<P> = P extends RecorderProvider<infer E> ? E : never;
 export { StreamManager };

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" +
                 /**
@@ -334,6 +381,9 @@ export function genSavePathFromRule(manager, recorder, extData) {
         channelId,
     };
     let savePathRule = manager.savePathRule;
+    if (extData?.extraMs) {
+        savePathRule += "_{ms}";
+    }
     try {
         savePathRule = ejs.render(savePathRule, params);
     }

package/lib/recorder.d.ts

@@ -93,6 +93,7 @@ export type GetSavePath = (data: {
     startTime: number;
     liveStartTime: Date;
     recordStartTime: Date;
+    extraMs?: boolean;
 }) => string;
 export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     RecordStart: RecordHandle;
@@ -132,6 +133,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
         cover: string;
         liveId?: string;
         recordStartTime: Date;
+        area?: string;
     };
     tempStopIntervalCheck?: boolean;
     /** 缓存实例（命名空间） */
@@ -152,6 +154,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.16.0",
   "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"
   },