@bililive-tools/manager 1.6.0 → 1.8.0

package/README.md

@@ -17,6 +17,7 @@
 | B站  | `@bililive-tools/bilibili-recorder` |
 | 斗鱼 | `@bililive-tools/douyu-recorder`    |
 | 虎牙 | `@bililive-tools/huya-recorder`     |
+| 抖音 | `@bililive-tools/douyin-recorder`   |
 
 # 使用
 
@@ -30,6 +31,8 @@ const manager = createRecorderManager({
   providers: [provider],
   savePathRule: "D:\\录制\\{platforme}}/{owner}/{year}-{month}-{date} {hour}-{min}-{sec} {title}", // 保存路径，占位符见文档，支持 [ejs](https://ejs.co/) 模板引擎
   autoCheckInterval: 1000 * 60, // 自动检查间隔，单位秒
+  maxThreadCount: 3, // 检查并发数
+  waitTime: 0, // 检查后等待时间
   autoRemoveSystemReservedChars: true, // 移除系统非法字符串
   biliBatchQuery: false, // B站检查使用批量接口
 });
@@ -75,13 +78,16 @@ manager.startCheckLoop();
 ### setFFMPEGPath & setMesioPath
 
 ```ts
-import { setFFMPEGPath, setMesioPath } from "@bililive-tools/manager";
+import { setFFMPEGPath, setMesioPath, setBililivePath } from "@bililive-tools/manager";
 
 // 设置ffmpeg可执行路径
 setFFMPEGPath("ffmpeg.exe");
 
 // 设置mesio可执行文件路径
 setMesioPath("mesio.exe");
+
+// 设置录播姬录制器的可执行文件路径
+setBililivePath("BililiveRecorder.Cli.exe");
 ```
 
 ## savePathRule 占位符参数

package/lib/index.d.ts

@@ -18,7 +18,9 @@ export declare function defaultToJSON<E extends AnyObject>(provider: RecorderPro
 export declare function genRecorderUUID(): Recorder["id"];
 export declare function genRecordUUID(): RecordHandle["id"];
 export declare function setFFMPEGPath(newPath: string): void;
-export declare const createFFMPEGBuilder: (input?: string | import("stream").Readable | undefined, options?: ffmpeg.FfmpegCommandOptions | undefined) => ffmpeg.FfmpegCommand;
+export declare const createFFMPEGBuilder: (...args: Parameters<typeof ffmpeg>) => ffmpeg.FfmpegCommand;
 export declare function setMesioPath(newPath: string): void;
 export declare function getMesioPath(): string;
+export declare function setBililivePath(newPath: string): void;
+export declare function getBililivePath(): string;
 export declare function getDataFolderPath<E extends AnyObject>(provider: RecorderProvider<E>): string;

package/lib/index.js

@@ -64,6 +64,13 @@ export function setMesioPath(newPath) {
 export function getMesioPath() {
     return mesioPath;
 }
+let bililivePath = "BililiveRecorder.Cli";
+export function setBililivePath(newPath) {
+    bililivePath = newPath;
+}
+export function getBililivePath() {
+    return bililivePath;
+}
 export function getDataFolderPath(provider) {
     return "./" + provider.id;
 }

package/lib/manager.d.ts

@@ -13,14 +13,14 @@ export interface RecorderProvider<E extends AnyObject> {
         id: ChannelId;
         title: string;
         owner: string;
-        uid?: number;
+        uid?: number | string;
         avatar?: string;
     } | null>;
     createRecorder: (this: RecorderProvider<E>, opts: Omit<RecorderCreateOpts<E>, "providerId">) => Recorder<E>;
     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", "ffmpegOutputArgs", "biliBatchQuery", "recordRetryImmediately"];
+declare const configurableProps: readonly ["savePathRule", "autoRemoveSystemReservedChars", "autoCheckInterval", "maxThreadCount", "waitTime", "ffmpegOutputArgs", "biliBatchQuery", "recordRetryImmediately"];
 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: {
@@ -39,6 +39,7 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
         recorder: SerializedRecorder<E>;
         filename: string;
         cover?: string;
+        rawFilename?: string;
     };
     videoFileCompleted: {
         recorder: SerializedRecorder<E>;
@@ -80,6 +81,8 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     stopRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
     cutRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
     autoCheckInterval: number;
+    maxThreadCount: number;
+    waitTime: number;
     isCheckLoopRunning: boolean;
     startCheckLoop: (this: RecorderManager<ME, P, PE, E>) => void;
     stopCheckLoop: (this: RecorderManager<ME, P, PE, E>) => void;

package/lib/manager.js

@@ -4,13 +4,15 @@ import ejs from "ejs";
 import { omit, range } from "lodash-es";
 import { parseArgsStringToArgv } from "string-argv";
 import { getBiliStatusInfoByRoomIds } from "./api.js";
-import { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, isBetweenTimeRange, } from "./utils.js";
+import { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, isBetweenTimeRange, sleep, } from "./utils.js";
 import { StreamManager } from "./recorder/streamManager.js";
 import { Cache } from "./cache.js";
 const configurableProps = [
     "savePathRule",
     "autoRemoveSystemReservedChars",
     "autoCheckInterval",
+    "maxThreadCount",
+    "waitTime",
     "ffmpegOutputArgs",
     "biliBatchQuery",
     "recordRetryImmediately",
@@ -38,7 +40,6 @@ export function createRecorderManager(opts) {
                 }
             }
         };
-        const maxThreadCount = 3;
         // 这里暂时不打算用 state == recording 来过滤，provider 必须内部自己处理录制过程中的 check，
         // 这样可以防止一些意外调用 checkLiveStatusAndRecord 时出现重复录制。
         let needCheckRecorders = recorders
@@ -75,10 +76,13 @@ export function createRecorderManager(opts) {
                 banLiveId,
             });
         };
-        threads = threads.concat(range(0, maxThreadCount).map(async () => {
+        threads = threads.concat(range(0, manager.maxThreadCount).map(async () => {
             while (needCheckRecorders.length > 0) {
                 try {
                     await checkOnce();
+                    if (manager.waitTime > 0) {
+                        await sleep(manager.waitTime);
+                    }
                 }
                 catch (err) {
                     manager.emit("error", { source: "checkOnceInThread", err });
@@ -116,12 +120,12 @@ export function createRecorderManager(opts) {
             this.recorders.push(recorder);
             recorder.on("RecordStart", (recordHandle) => this.emit("RecordStart", { recorder: recorder.toJSON(), recordHandle }));
             recorder.on("RecordSegment", (recordHandle) => this.emit("RecordSegment", { recorder: recorder.toJSON(), recordHandle }));
-            recorder.on("videoFileCreated", ({ filename, cover }) => {
+            recorder.on("videoFileCreated", ({ filename, cover, rawFilename }) => {
                 if (recorder.saveCover && recorder?.liveInfo?.cover) {
                     const coverPath = replaceExtName(filename, ".jpg");
                     downloadImage(cover ?? recorder?.liveInfo?.cover, coverPath);
                 }
-                this.emit("videoFileCreated", { recorder: recorder.toJSON(), filename });
+                this.emit("videoFileCreated", { recorder: recorder.toJSON(), filename, rawFilename });
             });
             recorder.on("videoFileCompleted", ({ filename }) => this.emit("videoFileCompleted", { recorder: recorder.toJSON(), filename }));
             recorder.on("Message", (message) => this.emit("Message", { recorder: recorder.toJSON(), message }));
@@ -227,6 +231,8 @@ export function createRecorderManager(opts) {
             return recorder;
         },
         autoCheckInterval: opts.autoCheckInterval ?? 1000,
+        maxThreadCount: opts.maxThreadCount ?? 3,
+        waitTime: opts.waitTime ?? 0,
         isCheckLoopRunning: false,
         startCheckLoop() {
             if (this.isCheckLoopRunning)

package/lib/recorder/BililiveRecorder.d.ts

@@ -0,0 +1,50 @@
+import EventEmitter from "node:events";
+import { IRecorder, BililiveRecorderOptions } from "./IRecorder.js";
+declare class BililiveRecorderCommand extends EventEmitter {
+    private _input;
+    private _output;
+    private _inputOptions;
+    private process;
+    constructor();
+    input(source: string): BililiveRecorderCommand;
+    output(target: string): BililiveRecorderCommand;
+    inputOptions(options: string[]): BililiveRecorderCommand;
+    inputOptions(...options: string[]): BililiveRecorderCommand;
+    _getArguments(): string[];
+    run(): void;
+    kill(signal?: NodeJS.Signals): void;
+}
+export declare const createBililiveBuilder: () => BililiveRecorderCommand;
+export declare class BililiveRecorder extends EventEmitter implements IRecorder {
+    private onEnd;
+    private onUpdateLiveInfo;
+    type: "bililive";
+    private command;
+    private streamManager;
+    readonly hasSegment: boolean;
+    readonly getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    readonly segment: number;
+    readonly inputOptions: string[];
+    readonly disableDanma: boolean;
+    readonly url: string;
+    readonly debugLevel: "none" | "basic" | "verbose";
+    readonly headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    constructor(opts: BililiveRecorderOptions, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+        title?: string;
+        cover?: string;
+    }>);
+    createCommand(): BililiveRecorderCommand;
+    formatLine(line: string): {
+        time: string | null;
+    } | null;
+    run(): void;
+    getArguments(): string[];
+    stop(): Promise<void>;
+    getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
+}
+export {};

package/lib/recorder/BililiveRecorder.js

@@ -0,0 +1,196 @@
+import EventEmitter from "node:events";
+import { spawn } from "node:child_process";
+import { StreamManager, getBililivePath } from "../index.js";
+// Bililive command builder class similar to ffmpeg
+class BililiveRecorderCommand extends EventEmitter {
+    _input = "";
+    _output = "";
+    _inputOptions = [];
+    process = null;
+    constructor() {
+        super();
+    }
+    input(source) {
+        this._input = source;
+        return this;
+    }
+    output(target) {
+        this._output = target;
+        return this;
+    }
+    inputOptions(...options) {
+        const opts = Array.isArray(options[0]) ? options[0] : options;
+        this._inputOptions.push(...opts);
+        return this;
+    }
+    _getArguments() {
+        const args = ["downloader", "-p"];
+        // Add input source
+        if (this._input) {
+            args.push(this._input);
+        }
+        // Add input options first
+        args.push(...this._inputOptions);
+        // Add output target
+        if (this._output) {
+            // const { dir, name } = path.parse(this._output);
+            // args.push("-o", dir);
+            args.push(this._output);
+        }
+        // args.push("-v");
+        return args;
+    }
+    run() {
+        const args = this._getArguments();
+        const bililiveExecutable = getBililivePath();
+        console.log("Starting BililiveRecorder with args:", bililiveExecutable, args);
+        this.process = spawn(bililiveExecutable, args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        if (this.process.stdout) {
+            this.process.stdout.on("data", (data) => {
+                const output = data.toString();
+                // console.log(output);
+                this.emit("stderr", output);
+            });
+        }
+        if (this.process.stderr) {
+            this.process.stderr.on("data", (data) => {
+                const output = data.toString();
+                // console.error(output);
+                this.emit("stderr", output);
+            });
+        }
+        this.process.on("error", (error) => {
+            this.emit("error", error);
+        });
+        [];
+        this.process.on("close", (code) => {
+            if (code === 0) {
+                this.emit("end");
+            }
+            else {
+                this.emit("error", new Error(`bililive process exited with code ${code}`));
+            }
+        });
+    }
+    kill(signal = "SIGTERM") {
+        if (this.process) {
+            this.process.kill(signal);
+        }
+    }
+}
+// Factory function similar to createFFMPEGBuilder
+export const createBililiveBuilder = () => {
+    return new BililiveRecorderCommand();
+};
+export class BililiveRecorder extends EventEmitter {
+    onEnd;
+    onUpdateLiveInfo;
+    type = "bililive";
+    command;
+    streamManager;
+    hasSegment;
+    getSavePath;
+    segment;
+    inputOptions = [];
+    disableDanma = false;
+    url;
+    debugLevel = "none";
+    headers;
+    constructor(opts, onEnd, onUpdateLiveInfo) {
+        super();
+        this.onEnd = onEnd;
+        this.onUpdateLiveInfo = onUpdateLiveInfo;
+        const hasSegment = true;
+        this.disableDanma = opts.disableDanma ?? false;
+        this.debugLevel = opts.debugLevel ?? "none";
+        let videoFormat = "flv";
+        this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "bililive", videoFormat, {
+            onUpdateLiveInfo: this.onUpdateLiveInfo,
+        });
+        this.hasSegment = hasSegment;
+        this.getSavePath = opts.getSavePath;
+        this.inputOptions = [];
+        this.url = opts.url;
+        this.segment = opts.segment;
+        this.headers = opts.headers;
+        this.command = this.createCommand();
+        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename }) => {
+            this.emit("videoFileCreated", { filename, cover, rawFilename });
+        });
+        this.streamManager.on("videoFileCompleted", ({ filename }) => {
+            this.emit("videoFileCompleted", { filename });
+        });
+        this.streamManager.on("DebugLog", (data) => {
+            this.emit("DebugLog", data);
+        });
+    }
+    createCommand() {
+        const inputOptions = [
+            ...this.inputOptions,
+            "-h",
+            "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
+        ];
+        if (this.debugLevel === "verbose") {
+            inputOptions.push("-l", "Debug");
+        }
+        if (this.headers) {
+            Object.entries(this.headers).forEach(([key, value]) => {
+                if (!value)
+                    return;
+                inputOptions.push("-h", `${key}: ${value}`);
+            });
+        }
+        if (this.hasSegment) {
+            inputOptions.push("-d", `${this.segment}`);
+        }
+        const command = createBililiveBuilder()
+            .input(this.url)
+            .inputOptions(inputOptions)
+            .output(this.streamManager.videoFilePath)
+            .on("error", this.onEnd)
+            .on("end", () => this.onEnd("finished"))
+            .on("stderr", async (stderrLine) => {
+            this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
+            await this.streamManager.handleVideoStarted(stderrLine);
+            const info = this.formatLine(stderrLine);
+            if (info) {
+                this.emit("progress", info);
+            }
+        });
+        return command;
+    }
+    formatLine(line) {
+        if (!line.includes("下载进度:")) {
+            return null;
+        }
+        let time = null;
+        const timeMatch = line.match(/录制时长:\s*([0-9:]+)\s/);
+        if (timeMatch) {
+            time = timeMatch[1];
+        }
+        return {
+            time,
+        };
+    }
+    run() {
+        this.command.run();
+    }
+    getArguments() {
+        return this.command._getArguments();
+    }
+    async stop() {
+        try {
+            // 直接发送SIGINT信号，会导致数据丢失
+            this.command.kill("SIGINT");
+            await this.streamManager.handleVideoCompleted();
+        }
+        catch (err) {
+            this.emit("DebugLog", { type: "error", text: String(err) });
+        }
+    }
+    getExtraDataController() {
+        return this.streamManager?.getExtraDataController();
+    }
+}

package/lib/recorder/FFMPEGRecorder.d.ts

@@ -1,42 +1,31 @@
 import EventEmitter from "node:events";
-export declare class FFMPEGRecorder extends EventEmitter {
+import { IRecorder, FFMPEGRecorderOptions } from "./IRecorder.js";
+import type { FormatName } from "./index.js";
+export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
     private onEnd;
     private onUpdateLiveInfo;
+    type: "ffmpeg";
     private command;
     private streamManager;
     private timeoutChecker;
-    hasSegment: boolean;
-    getSavePath: (data: {
+    readonly hasSegment: boolean;
+    readonly getSavePath: (data: {
         startTime: number;
         title?: string;
     }) => string;
-    segment: number;
+    readonly segment: number;
     ffmpegOutputOptions: string[];
-    inputOptions: string[];
-    isHls: boolean;
-    disableDanma: boolean;
-    url: string;
-    formatName: "flv" | "ts" | "fmp4";
+    readonly inputOptions: string[];
+    readonly isHls: boolean;
+    readonly disableDanma: boolean;
+    readonly url: string;
+    formatName: FormatName;
     videoFormat: "ts" | "mkv" | "mp4";
-    headers: {
+    readonly debugLevel: "none" | "basic" | "verbose";
+    readonly headers: {
         [key: string]: string | undefined;
     } | undefined;
-    constructor(opts: {
-        url: string;
-        getSavePath: (data: {
-            startTime: number;
-            title?: string;
-        }) => string;
-        segment: number;
-        outputOptions: string[];
-        inputOptions?: string[];
-        disableDanma?: boolean;
-        videoFormat?: "auto" | "ts" | "mkv" | "mp4";
-        formatName?: "flv" | "ts" | "fmp4";
-        headers?: {
-            [key: string]: string | undefined;
-        };
-    }, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+    constructor(opts: FFMPEGRecorderOptions, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
         title?: string;
         cover?: string;
     }>);
@@ -47,5 +36,5 @@ export declare class FFMPEGRecorder extends EventEmitter {
     run(): void;
     getArguments(): string[];
     stop(): Promise<void>;
-    getExtraDataController(): import("../record_extra_data_controller.js").RecordExtraDataController | null;
+    getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
 }

package/lib/recorder/FFMPEGRecorder.js

@@ -4,6 +4,7 @@ import { createInvalidStreamChecker, assert } from "../utils.js";
 export class FFMPEGRecorder extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
+    type = "ffmpeg";
     command;
     streamManager;
     timeoutChecker;
@@ -17,6 +18,7 @@ export class FFMPEGRecorder extends EventEmitter {
     url;
     formatName;
     videoFormat;
+    debugLevel = "none";
     headers;
     constructor(opts, onEnd, onUpdateLiveInfo) {
         super();
@@ -24,11 +26,8 @@ export class FFMPEGRecorder extends EventEmitter {
         this.onUpdateLiveInfo = onUpdateLiveInfo;
         const hasSegment = !!opts.segment;
         this.hasSegment = hasSegment;
-        let formatName = "flv";
-        if (opts.url.includes(".m3u8")) {
-            formatName = "ts";
-        }
-        this.formatName = opts.formatName ?? formatName;
+        this.debugLevel = opts.debugLevel ?? "none";
+        this.formatName = opts.formatName;
         if (this.formatName === "fmp4" || this.formatName === "ts") {
             this.isHls = true;
         }
@@ -60,8 +59,8 @@ export class FFMPEGRecorder extends EventEmitter {
         this.segment = opts.segment;
         this.headers = opts.headers;
         this.command = this.createCommand();
-        this.streamManager.on("videoFileCreated", ({ filename, cover }) => {
-            this.emit("videoFileCreated", { filename, cover });
+        this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename }) => {
+            this.emit("videoFileCreated", { filename, cover, rawFilename });
         });
         this.streamManager.on("videoFileCompleted", ({ filename }) => {
             this.emit("videoFileCompleted", { filename });
@@ -79,6 +78,12 @@ export class FFMPEGRecorder extends EventEmitter {
             "-user_agent",
             "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36",
         ];
+        if (this.isHls) {
+            inputOptions.push(...["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "3"]);
+        }
+        if (this.debugLevel === "verbose") {
+            inputOptions.push("-loglevel", "debug");
+        }
         if (this.headers) {
             const headers = [];
             Object.entries(this.headers).forEach(([key, value]) => {

package/lib/recorder/IRecorder.d.ts

@@ -0,0 +1,90 @@
+import { EventEmitter } from "node:events";
+import type { FormatName } from "./index.js";
+/**
+ * 录制器构造函数选项的基础接口
+ */
+export interface BaseRecorderOptions {
+    url: string;
+    getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    segment: number;
+    inputOptions?: string[];
+    disableDanma?: boolean;
+    formatName: FormatName;
+    debugLevel?: "none" | "basic" | "verbose";
+    headers?: {
+        [key: string]: string | undefined;
+    };
+    videoFormat?: "auto" | "ts" | "mkv" | "mp4";
+}
+/**
+ * 录制器接口定义
+ */
+export interface IRecorder extends EventEmitter {
+    type: "ffmpeg" | "mesio" | "bililive";
+    readonly hasSegment: boolean;
+    readonly segment: number;
+    readonly inputOptions: string[];
+    readonly disableDanma: boolean;
+    readonly url: string;
+    readonly headers: {
+        [key: string]: string | undefined;
+    } | undefined;
+    readonly getSavePath: (data: {
+        startTime: number;
+        title?: string;
+    }) => string;
+    run(): void;
+    stop(): Promise<void>;
+    getArguments(): string[];
+    getExtraDataController(): any;
+    createCommand(): any;
+    on(event: "videoFileCreated", listener: (data: {
+        filename: string;
+        cover?: string;
+        rawFilename?: string;
+    }) => void): this;
+    on(event: "videoFileCompleted", listener: (data: {
+        filename: string;
+    }) => void): this;
+    on(event: "DebugLog", listener: (data: {
+        type: string;
+        text: string;
+    }) => void): this;
+    on(event: "progress", listener: (info: any) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    emit(event: "videoFileCreated", data: {
+        filename: string;
+        cover?: string;
+        rawFilename?: string;
+    }): boolean;
+    emit(event: "videoFileCompleted", data: {
+        filename: string;
+    }): boolean;
+    emit(event: "DebugLog", data: {
+        type: string;
+        text: string;
+    }): boolean;
+    emit(event: "progress", info: any): boolean;
+    emit(event: string, ...args: any[]): boolean;
+}
+/**
+ * FFMPEG录制器特定选项
+ */
+export interface FFMPEGRecorderOptions extends BaseRecorderOptions {
+    outputOptions: string[];
+}
+/**
+ * Mesio录制器特定选项
+ */
+export interface MesioRecorderOptions extends BaseRecorderOptions {
+    outputOptions?: string[];
+}
+/**
+ * Bililive录制器特定选项
+ */
+export interface BililiveRecorderOptions extends BaseRecorderOptions {
+    outputOptions?: string[];
+}

package/lib/recorder/IRecorder.js

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