@bililive-tools/manager 1.6.1 → 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

@@ -21,4 +21,6 @@ export declare function setFFMPEGPath(newPath: string): void;
 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

@@ -20,7 +20,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", "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,8 +1,10 @@
 import EventEmitter from "node:events";
 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;
@@ -17,8 +19,9 @@ export declare class FFMPEGRecorder extends EventEmitter implements IRecorder {
     readonly isHls: boolean;
     readonly disableDanma: boolean;
     readonly url: string;
-    formatName: "flv" | "ts" | "fmp4";
+    formatName: FormatName;
     videoFormat: "ts" | "mkv" | "mp4";
+    readonly debugLevel: "none" | "basic" | "verbose";
     readonly headers: {
         [key: string]: string | undefined;
     } | undefined;

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

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import type { FormatName } from "./index.js";
 /**
  * 录制器构造函数选项的基础接口
  */
@@ -11,19 +12,21 @@ export interface BaseRecorderOptions {
     segment: number;
     inputOptions?: string[];
     disableDanma?: boolean;
-    formatName?: "flv" | "ts" | "fmp4";
+    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 isHls: boolean;
     readonly disableDanma: boolean;
     readonly url: string;
     readonly headers: {
@@ -41,6 +44,7 @@ export interface IRecorder extends EventEmitter {
     on(event: "videoFileCreated", listener: (data: {
         filename: string;
         cover?: string;
+        rawFilename?: string;
     }) => void): this;
     on(event: "videoFileCompleted", listener: (data: {
         filename: string;
@@ -54,6 +58,7 @@ export interface IRecorder extends EventEmitter {
     emit(event: "videoFileCreated", data: {
         filename: string;
         cover?: string;
+        rawFilename?: string;
     }): boolean;
     emit(event: "videoFileCompleted", data: {
         filename: string;
@@ -70,12 +75,16 @@ export interface IRecorder extends EventEmitter {
  */
 export interface FFMPEGRecorderOptions extends BaseRecorderOptions {
     outputOptions: string[];
-    videoFormat?: "auto" | "ts" | "mkv" | "mp4";
 }
 /**
  * Mesio录制器特定选项
  */
 export interface MesioRecorderOptions extends BaseRecorderOptions {
     outputOptions?: string[];
-    isHls?: boolean;
+}
+/**
+ * Bililive录制器特定选项
+ */
+export interface BililiveRecorderOptions extends BaseRecorderOptions {
+    outputOptions?: string[];
 }

package/lib/recorder/index.d.ts

@@ -1,25 +1,47 @@
 import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-import { mesioRecorder } from "./mesioRecorder.js";
+import { MesioRecorder } from "./mesioRecorder.js";
+import { BililiveRecorder } from "./BililiveRecorder.js";
 export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-export { mesioRecorder } from "./mesioRecorder.js";
-import type { IRecorder, FFMPEGRecorderOptions, MesioRecorderOptions } from "./IRecorder.js";
+export { MesioRecorder } from "./mesioRecorder.js";
+export { BililiveRecorder } from "./BililiveRecorder.js";
+import type { IRecorder, FFMPEGRecorderOptions, MesioRecorderOptions, BililiveRecorderOptions } from "./IRecorder.js";
 /**
  * 录制器类型
  */
-export type RecorderType = "ffmpeg" | "mesio";
+export type RecorderType = "ffmpeg" | "mesio" | "bililive";
+export type FormatName = "flv" | "ts" | "fmp4";
 /**
  * 根据录制器类型获取对应的配置选项类型
  */
-export type RecorderOptions<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorderOptions : MesioRecorderOptions;
+export type RecorderOptions<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorderOptions : T extends "mesio" ? MesioRecorderOptions : BililiveRecorderOptions;
 /**
  * 根据录制器类型获取对应的录制器实例类型
  */
-export type RecorderInstance<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorder : mesioRecorder;
+export type RecorderInstance<T extends RecorderType> = T extends "ffmpeg" ? FFMPEGRecorder : T extends "mesio" ? MesioRecorder : BililiveRecorder;
+type RecorderOpts = FFMPEGRecorderOptions | MesioRecorderOptions | BililiveRecorderOptions;
 /**
  * 创建录制器的工厂函数
  */
-export declare function createBaseRecorder<T extends RecorderType>(type: T, opts: RecorderOptions<T> & {
-    mesioOptions?: string[];
+export declare function createRecorder<T extends RecorderType>(type: T, opts: RecorderOptions<T> & {
+    onlyAudio?: boolean;
+}, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
+    title?: string;
+    cover?: string;
+}>): IRecorder;
+/**
+ * 选择录制器
+ */
+export declare function selectRecorder(preferredRecorder: "auto" | RecorderType | undefined): RecorderType;
+/**
+ * 判断原始录制流格式，flv, ts, m4s
+ */
+export declare function getSourceFormatName(streamUrl: string, formatName: FormatName | undefined): FormatName;
+type PickPartial<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Partial<Pick<T, K>>;
+/**
+ * 创建录制器的工厂函数
+ */
+export declare function createBaseRecorder(type: "auto" | RecorderType | undefined, opts: PickPartial<RecorderOpts, "formatName"> & {
+    onlyAudio?: boolean;
 }, onEnd: (...args: unknown[]) => void, onUpdateLiveInfo: () => Promise<{
     title?: string;
     cover?: string;

package/lib/recorder/index.js

@@ -1,18 +1,78 @@
 import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-import { mesioRecorder } from "./mesioRecorder.js";
+import { MesioRecorder } from "./mesioRecorder.js";
+import { BililiveRecorder } from "./BililiveRecorder.js";
 export { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-export { mesioRecorder } from "./mesioRecorder.js";
+export { MesioRecorder } from "./mesioRecorder.js";
+export { BililiveRecorder } from "./BililiveRecorder.js";
 /**
  * 创建录制器的工厂函数
  */
-export function createBaseRecorder(type, opts, onEnd, onUpdateLiveInfo) {
+export function createRecorder(type, opts, onEnd, onUpdateLiveInfo) {
     if (type === "ffmpeg") {
         return new FFMPEGRecorder(opts, onEnd, onUpdateLiveInfo);
     }
     else if (type === "mesio") {
-        return new mesioRecorder({ ...opts, inputOptions: opts.mesioOptions ?? [] }, onEnd, onUpdateLiveInfo);
+        return new MesioRecorder(opts, onEnd, onUpdateLiveInfo);
+    }
+    else if (type === "bililive") {
+        if (opts.formatName === "flv") {
+            // 录播姬引擎不支持只录音频
+            if (!opts.onlyAudio) {
+                return new BililiveRecorder(opts, onEnd, onUpdateLiveInfo);
+            }
+        }
+        return new FFMPEGRecorder(opts, onEnd, onUpdateLiveInfo);
     }
     else {
         throw new Error(`Unsupported recorder type: ${type}`);
     }
 }
+/**
+ * 选择录制器
+ */
+export function selectRecorder(preferredRecorder) {
+    let recorderType;
+    if (preferredRecorder === "auto") {
+        // 默认优先使用ffmpeg录制器
+        recorderType = "ffmpeg";
+    }
+    else if (preferredRecorder === "ffmpeg") {
+        recorderType = "ffmpeg";
+    }
+    else if (preferredRecorder === "mesio") {
+        recorderType = "mesio";
+    }
+    else if (preferredRecorder === "bililive") {
+        recorderType = "bililive";
+    }
+    else {
+        recorderType = "ffmpeg";
+    }
+    return recorderType;
+}
+/**
+ * 判断原始录制流格式，flv, ts, m4s
+ */
+export function getSourceFormatName(streamUrl, formatName) {
+    if (formatName) {
+        return formatName;
+    }
+    if (streamUrl.includes(".m3u8")) {
+        return "ts";
+    }
+    else if (streamUrl.includes(".m4s")) {
+        // TODO: 使用b站的流进行测试
+        return "fmp4";
+    }
+    else {
+        return "flv";
+    }
+}
+/**
+ * 创建录制器的工厂函数
+ */
+export function createBaseRecorder(type, opts, onEnd, onUpdateLiveInfo) {
+    const recorderType = selectRecorder(type);
+    const sourceFormatName = getSourceFormatName(opts.url, opts.formatName);
+    return createRecorder(recorderType, { ...opts, formatName: sourceFormatName }, onEnd, onUpdateLiveInfo);
+}

package/lib/recorder/mesioRecorder.d.ts

@@ -15,9 +15,10 @@ declare class MesioCommand extends EventEmitter {
     kill(signal?: NodeJS.Signals): void;
 }
 export declare const createMesioBuilder: () => MesioCommand;
-export declare class mesioRecorder extends EventEmitter implements IRecorder {
+export declare class MesioRecorder extends EventEmitter implements IRecorder {
     private onEnd;
     private onUpdateLiveInfo;
+    type: "mesio";
     private command;
     private streamManager;
     readonly hasSegment: boolean;
@@ -27,9 +28,9 @@ export declare class mesioRecorder extends EventEmitter implements IRecorder {
     }) => string;
     readonly segment: number;
     readonly inputOptions: string[];
-    readonly isHls: boolean;
     readonly disableDanma: boolean;
     readonly url: string;
+    readonly debugLevel: "none" | "basic" | "verbose";
     readonly headers: {
         [key: string]: string | undefined;
     } | undefined;

package/lib/recorder/mesioRecorder.js

@@ -84,18 +84,19 @@ class MesioCommand extends EventEmitter {
 export const createMesioBuilder = () => {
     return new MesioCommand();
 };
-export class mesioRecorder extends EventEmitter {
+export class MesioRecorder extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
+    type = "mesio";
     command;
     streamManager;
     hasSegment;
     getSavePath;
     segment;
     inputOptions = [];
-    isHls;
     disableDanma = false;
     url;
+    debugLevel = "none";
     headers;
     constructor(opts, onEnd, onUpdateLiveInfo) {
         super();
@@ -103,39 +104,32 @@ export class mesioRecorder extends EventEmitter {
         this.onUpdateLiveInfo = onUpdateLiveInfo;
         const hasSegment = true;
         this.disableDanma = opts.disableDanma ?? false;
+        this.debugLevel = opts.debugLevel ?? "none";
         let videoFormat = "flv";
         if (opts.url.includes(".m3u8")) {
             videoFormat = "ts";
         }
-        if (opts.formatName) {
-            if (opts.formatName === "fmp4") {
-                videoFormat = "m4s";
-            }
-            else if (opts.formatName === "ts") {
-                videoFormat = "ts";
-            }
-            else if (opts.formatName === "flv") {
-                videoFormat = "flv";
-            }
+        if (opts.formatName === "fmp4") {
+            videoFormat = "m4s";
+        }
+        else if (opts.formatName === "ts") {
+            videoFormat = "ts";
+        }
+        else if (opts.formatName === "flv") {
+            videoFormat = "flv";
         }
         this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "mesio", videoFormat, {
             onUpdateLiveInfo: this.onUpdateLiveInfo,
         });
         this.hasSegment = hasSegment;
         this.getSavePath = opts.getSavePath;
-        this.inputOptions = opts.inputOptions ?? [];
+        this.inputOptions = [];
         this.url = opts.url;
         this.segment = opts.segment;
         this.headers = opts.headers;
-        if (opts.isHls === undefined) {
-            this.isHls = this.url.includes("m3u8");
-        }
-        else {
-            this.isHls = opts.isHls;
-        }
         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 });
@@ -151,6 +145,9 @@ export class mesioRecorder extends EventEmitter {
             "-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("-v");
+        }
         if (this.headers) {
             Object.entries(this.headers).forEach(([key, value]) => {
                 if (!value)
@@ -168,8 +165,8 @@ export class mesioRecorder extends EventEmitter {
             .on("error", this.onEnd)
             .on("end", () => this.onEnd("finished"))
             .on("stderr", async (stderrLine) => {
-            await this.streamManager.handleVideoStarted(stderrLine);
             this.emit("DebugLog", { type: "ffmpeg", text: stderrLine });
+            await this.streamManager.handleVideoStarted(stderrLine);
         });
         return command;
     }

package/lib/recorder/streamManager.js

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import fs from "fs/promises";
 import { createRecordExtraDataController } from "../xml_stream_controller.js";
-import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isMesioStartSegment, isFfmpegStart, retry, cleanTerminalText, } from "../utils.js";
+import { replaceExtName, ensureFolderExist, isFfmpegStartSegment, isMesioStartSegment, isBililiveStartSegment, isFfmpegStart, retry, cleanTerminalText, } from "../utils.js";
 export class Segment extends EventEmitter {
     extraDataController = null;
     init = true;
@@ -27,8 +27,12 @@ export class Segment extends EventEmitter {
             return;
         }
         try {
+            this.emit("DebugLog", {
+                type: "info",
+                text: `Renaming segment file: ${this.rawRecordingVideoPath} -> ${this.outputFilePath}`,
+            });
             await Promise.all([
-                retry(() => fs.rename(this.rawRecordingVideoPath, this.outputFilePath), 10, 2000),
+                retry(() => fs.rename(this.rawRecordingVideoPath, this.outputFilePath), 20, 1000),
                 this.extraDataController?.flush(),
             ]);
             this.emit("videoFileCompleted", { filename: this.outputFilePath });
@@ -38,6 +42,8 @@ export class Segment extends EventEmitter {
                 type: "error",
                 text: "videoFileCompleted error " + String(err),
             });
+            // 虽然重命名失败了，但是也当作完成处理，避免卡住录制流程
+            this.emit("videoFileCompleted", { filename: this.outputFilePath });
         }
     }
     async onSegmentStart(stderrLine, callBack) {
@@ -75,14 +81,17 @@ export class Segment extends EventEmitter {
         if (!match) {
             match = cleanTerminalText(stderrLine).match(mesioRegex);
         }
+        this.emit("DebugLog", { type: "ffmpeg", text: `Segment start line: ${stderrLine}` });
         if (match) {
             const filename = match[1];
             this.rawRecordingVideoPath = filename;
             this.emit("videoFileCreated", {
+                rawFilename: filename,
                 filename: this.outputFilePath,
                 title: liveInfo?.title,
                 cover: liveInfo?.cover,
             });
+            this.emit("DebugLog", { type: "ffmpeg", text: JSON.stringify(match, null, 2) });
         }
         else {
             this.emit("DebugLog", { type: "ffmpeg", text: "No match found" });
@@ -147,6 +156,15 @@ export class StreamManager extends EventEmitter {
         }
         else if (this.recorderType === "mesio") {
             if (this.segment && isMesioStartSegment(stderrLine)) {
+                for (let line of stderrLine.split("\n")) {
+                    if (isMesioStartSegment(line)) {
+                        await this.segment.onSegmentStart(line, this.callBack);
+                    }
+                }
+            }
+        }
+        else if (this.recorderType === "bililive") {
+            if (this.segment && isBililiveStartSegment(stderrLine)) {
                 await this.segment.onSegmentStart(stderrLine, this.callBack);
             }
         }
@@ -168,6 +186,11 @@ export class StreamManager extends EventEmitter {
                 await this.segment.handleSegmentEnd();
             }
         }
+        else if (this.recorderType === "bililive") {
+            if (this.segment) {
+                await this.segment.handleSegmentEnd();
+            }
+        }
     }
     getExtraDataController() {
         return this.segment?.extraDataController || this.extraDataController;
@@ -179,6 +202,9 @@ export class StreamManager extends EventEmitter {
         else if (this.recorderType === "mesio") {
             return this.videoFormat;
         }
+        else if (this.recorderType === "bililive") {
+            return "flv";
+        }
         else {
             throw new Error("Unknown recorderType");
         }
@@ -192,6 +218,9 @@ export class StreamManager extends EventEmitter {
         else if (this.recorderType === "mesio") {
             return `${this.recordSavePath}-PART%i.${this.videoExt}`;
         }
+        else if (this.recorderType === "bililive") {
+            return `${this.recordSavePath}.${this.videoExt}`;
+        }
         return `${this.recordSavePath}.${this.videoExt}`;
     }
 }

package/lib/recorder.d.ts

@@ -46,7 +46,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     /** 用于指定录制文件格式，auto时，分段使用ts，不分段使用mp4 */
     videoFormat?: "auto" | "ts" | "mkv";
     /** 录制类型 */
-    recorderType?: "auto" | "ffmpeg" | "mesio";
+    recorderType?: "auto" | "ffmpeg" | "mesio" | "bililive";
     /** 流格式优先级 */
     formatriorities?: Array<"flv" | "hls">;
     /** 只录制音频 */
@@ -56,10 +56,14 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     /** 控制弹幕是否使用服务端时间戳 */
     useServerTimestamp?: boolean;
     extra?: Partial<E>;
+    /** 调试等级 */
+    debugLevel?: "none" | "basic" | "verbose";
+    /** 缓存 */
     cache: Cache;
 }
 export type SerializedRecorder<E extends AnyObject> = PickRequired<RecorderCreateOpts<E>, "id"> & Pick<Recorder<E>, "id" | "channelId" | "remarks" | "disableAutoCheck" | "quality" | "streamPriorities" | "sourcePriorities" | "extra" | "segment" | "saveSCDanma" | "saveCover" | "saveGiftDanma" | "disableProvideCommentsWhenRecording" | "liveInfo" | "uid" | "titleKeywords">;
-export type RecorderState = "idle" | "recording" | "stopping-record" | "check-error";
+/** 录制状态，idle: 空闲中，recording: 录制中，stopping-record: 停止录制中，check-error: 检查错误，title-blocked: 标题黑名单 */
+export type RecorderState = "idle" | "recording" | "stopping-record" | "check-error" | "title-blocked";
 export type Progress = {
     time: string | null;
 };
@@ -89,6 +93,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     videoFileCreated: {
         filename: string;
         cover?: string;
+        rawFilename?: string;
     };
     videoFileCompleted: {
         filename: string;

package/lib/utils.d.ts

@@ -37,6 +37,7 @@ export declare function formatDate(date: Date, format: string): string;
 export declare function removeSystemReservedChars(filename: string): string;
 export declare function isFfmpegStartSegment(line: string): boolean;
 export declare function isMesioStartSegment(line: string): boolean;
+export declare function isBililiveStartSegment(line: string): boolean;
 export declare function isFfmpegStart(line: string): boolean;
 export declare function cleanTerminalText(text: string): string;
 export declare const formatTemplate: (string: string, ...args: any[]) => string;
@@ -72,6 +73,15 @@ export declare function sortByKeyOrder<T, K extends keyof T>(objects: T[], order
  */
 export declare function retry<T>(fn: () => Promise<T>, retries?: number, delay?: number): Promise<T>;
 export declare const isBetweenTimeRange: (range: undefined | [] | [string | null, string | null]) => boolean;
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * 检查标题是否包含黑名单关键词
+ */
+declare function hasBlockedTitleKeywords(title: string, titleKeywords: string | undefined): boolean;
+/**
+ * 检查是否需要进行标题关键词检查
+ */
+declare function shouldCheckTitleKeywords(isManualStart: boolean | undefined, titleKeywords: string | undefined): boolean;
 declare const _default: {
     replaceExtName: typeof replaceExtName;
     singleton: typeof singleton;
@@ -91,5 +101,8 @@ declare const _default: {
     sortByKeyOrder: typeof sortByKeyOrder;
     retry: typeof retry;
     isBetweenTimeRange: (range: undefined | [] | [string | null, string | null]) => boolean;
+    hasBlockedTitleKeywords: typeof hasBlockedTitleKeywords;
+    shouldCheckTitleKeywords: typeof shouldCheckTitleKeywords;
+    sleep: (ms: number) => Promise<unknown>;
 };
 export default _default;

package/lib/utils.js

@@ -127,7 +127,10 @@ export function isFfmpegStartSegment(line) {
     return line.includes("Opening ") && line.includes("for writing");
 }
 export function isMesioStartSegment(line) {
-    return line.includes("Opening ") && line.includes("Opening segment");
+    return line.includes("Opening segment");
+}
+export function isBililiveStartSegment(line) {
+    return line.includes("创建录制文件");
 }
 export function isFfmpegStart(line) {
     return ((line.includes("frame=") && line.includes("fps=")) ||
@@ -323,6 +326,23 @@ function isBetweenTime(currentTime, timeRange) {
     }
     return start <= current && current <= end;
 }
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * 检查标题是否包含黑名单关键词
+ */
+function hasBlockedTitleKeywords(title, titleKeywords) {
+    const keywords = (titleKeywords ?? "")
+        .split(",")
+        .map((k) => k.trim())
+        .filter((k) => k);
+    return keywords.some((keyword) => title.toLowerCase().includes(keyword.toLowerCase()));
+}
+/**
+ * 检查是否需要进行标题关键词检查
+ */
+function shouldCheckTitleKeywords(isManualStart, titleKeywords) {
+    return (!isManualStart && !!titleKeywords && typeof titleKeywords === "string" && !!titleKeywords.trim());
+}
 export default {
     replaceExtName,
     singleton,
@@ -342,4 +362,7 @@ export default {
     sortByKeyOrder,
     retry,
     isBetweenTimeRange,
+    hasBlockedTitleKeywords,
+    shouldCheckTitleKeywords,
+    sleep,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/manager",
-  "version": "1.6.1",
+  "version": "1.8.0",
   "description": "Batch scheduling recorders",
   "main": "./lib/index.js",
   "type": "module",