@bililive-tools/manager 1.9.0 → 1.11.0

package/lib/{recorder/mesioRecorder.js → downloader/mesioDownloader.js}

@@ -1,8 +1,8 @@
 import path from "node:path";
 import EventEmitter from "node:events";
 import { spawn } from "node:child_process";
+import { DEFAULT_USER_AGENT } from "./index.js";
 import { StreamManager, getMesioPath } from "../index.js";
-// Mesio command builder class similar to ffmpeg
 class MesioCommand extends EventEmitter {
     _input = "";
     _output = "";
@@ -74,9 +74,10 @@ class MesioCommand extends EventEmitter {
             }
         });
     }
-    kill(signal = "SIGTERM") {
+    kill() {
         if (this.process) {
-            this.process.kill(signal);
+            this.process.stdin?.write("q");
+            this.process.stdin?.end();
         }
     }
 }
@@ -84,7 +85,7 @@ class MesioCommand extends EventEmitter {
 export const createMesioBuilder = () => {
     return new MesioCommand();
 };
-export class MesioRecorder extends EventEmitter {
+export class mesioDownloader extends EventEmitter {
     onEnd;
     onUpdateLiveInfo;
     type = "mesio";
@@ -102,7 +103,9 @@ export class MesioRecorder extends EventEmitter {
         super();
         this.onEnd = onEnd;
         this.onUpdateLiveInfo = onUpdateLiveInfo;
+        // 存在自动分段，永远为true
         const hasSegment = true;
+        this.hasSegment = hasSegment;
         this.disableDanma = opts.disableDanma ?? false;
         this.debugLevel = opts.debugLevel ?? "none";
         let videoFormat = "flv";
@@ -121,12 +124,14 @@ export class MesioRecorder extends EventEmitter {
         this.streamManager = new StreamManager(opts.getSavePath, hasSegment, this.disableDanma, "mesio", 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.headers = {
+            "User-Agent": DEFAULT_USER_AGENT,
+            ...(opts.headers || {}),
+        };
         this.command = this.createCommand();
         this.streamManager.on("videoFileCreated", ({ filename, cover, rawFilename, title }) => {
             this.emit("videoFileCreated", { filename, cover, rawFilename, title });
@@ -139,13 +144,7 @@ export class MesioRecorder extends EventEmitter {
         });
     }
     createCommand() {
-        const inputOptions = [
-            ...this.inputOptions,
-            "--fix",
-            "-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",
-            "--no-proxy",
-        ];
+        const inputOptions = [...this.inputOptions, "--fix", "--no-proxy"];
         if (this.debugLevel === "verbose") {
             inputOptions.push("-v");
         }
@@ -156,8 +155,13 @@ export class MesioRecorder extends EventEmitter {
                 inputOptions.push("-H", `${key}: ${value}`);
             });
         }
-        if (this.hasSegment) {
-            inputOptions.push("-d", `${this.segment * 60}s`);
+        if (this.segment) {
+            if (typeof this.segment === "number") {
+                inputOptions.push("-d", `${this.segment * 60}s`);
+            }
+            else if (typeof this.segment === "string") {
+                inputOptions.push("-m", this.segment);
+            }
         }
         const command = createMesioBuilder()
             .input(this.url)
@@ -179,8 +183,8 @@ export class MesioRecorder extends EventEmitter {
     }
     async stop() {
         try {
-            // 直接发送SIGINT信号，会导致数据丢失
-            this.command.kill("SIGINT");
+            this.command.kill();
+            await new Promise((resolve) => setTimeout(resolve, 2000));
             await this.streamManager.handleVideoCompleted();
         }
         catch (err) {
@@ -190,4 +194,10 @@ export class MesioRecorder extends EventEmitter {
     getExtraDataController() {
         return this.streamManager?.getExtraDataController();
     }
+    get videoFilePath() {
+        return this.streamManager.videoFilePath;
+    }
+    cut() {
+        throw new Error("Mesio downloader does not support cut operation.");
+    }
 }

package/lib/{recorder → downloader}/streamManager.d.ts

@@ -1,7 +1,7 @@
 import EventEmitter from "node:events";
 import { createRecordExtraDataController } from "../xml_stream_controller.js";
 import type { RecorderCreateOpts } from "../recorder.js";
-import type { VideoFormat } from "../index.js";
+import type { TrueVideoFormat } from "../index.js";
 export type GetSavePath = (data: {
     startTime: number;
     title?: string;
@@ -16,8 +16,8 @@ export declare class Segment extends EventEmitter {
     /** 输出文件名名，不包含拓展名 */
     outputVideoFilePath: string;
     disableDanma: boolean;
-    videoExt: VideoFormat;
-    constructor(getSavePath: GetSavePath, disableDanma: boolean, videoExt: VideoFormat);
+    videoExt: TrueVideoFormat;
+    constructor(getSavePath: GetSavePath, disableDanma: boolean, videoExt: TrueVideoFormat);
     handleSegmentEnd(): Promise<void>;
     onSegmentStart(stderrLine: string, callBack?: {
         onUpdateLiveInfo: () => Promise<{
@@ -36,7 +36,7 @@ export declare class StreamManager extends EventEmitter {
     recorderType: RecorderType;
     private videoFormat;
     private callBack?;
-    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean, recorderType: RecorderType, videoFormat: VideoFormat, callBack?: {
+    constructor(getSavePath: GetSavePath, hasSegment: boolean, disableDanma: boolean, recorderType: RecorderType, videoFormat: TrueVideoFormat, callBack?: {
         onUpdateLiveInfo: () => Promise<{
             title?: string;
             cover?: string;
@@ -45,7 +45,7 @@ export declare class StreamManager extends EventEmitter {
     handleVideoStarted(stderrLine: string): Promise<void>;
     handleVideoCompleted(): Promise<void>;
     getExtraDataController(): import("../xml_stream_controller.js").XmlStreamController | null;
-    get videoExt(): VideoFormat;
+    get videoExt(): TrueVideoFormat;
     get videoFilePath(): string;
 }
 export {};

package/lib/{recorder → downloader}/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, isBililiveStartSegment, isFfmpegStart, retry, cleanTerminalText, } from "../utils.js";
+import { ensureFolderExist, isFfmpegStartSegment, isMesioStartSegment, isBililiveStartSegment, isFfmpegStart, retry, cleanTerminalText, } from "../utils.js";
 export class Segment extends EventEmitter {
     extraDataController = null;
     init = true;
@@ -107,14 +107,14 @@ export class StreamManager extends EventEmitter {
     recordSavePath;
     recordStartTime;
     hasSegment;
-    recorderType = "ffmpeg";
+    recorderType;
     videoFormat;
     callBack;
     constructor(getSavePath, hasSegment, disableDanma, recorderType, videoFormat, callBack) {
         super();
         const recordSavePath = getSavePath({ startTime: Date.now() });
         this.recordSavePath = recordSavePath;
-        this.videoFormat = videoFormat ?? "auto";
+        this.videoFormat = videoFormat;
         this.recorderType = recorderType;
         this.hasSegment = hasSegment;
         this.callBack = callBack;
@@ -131,7 +131,7 @@ export class StreamManager extends EventEmitter {
             });
         }
         else {
-            const extraDataSavePath = replaceExtName(recordSavePath, ".xml");
+            const extraDataSavePath = `${recordSavePath}.xml`;
             if (!disableDanma) {
                 this.extraDataController = createRecordExtraDataController(extraDataSavePath);
             }
@@ -196,18 +196,7 @@ export class StreamManager extends EventEmitter {
         return this.segment?.extraDataController || this.extraDataController;
     }
     get videoExt() {
-        if (this.recorderType === "ffmpeg") {
-            return this.videoFormat;
-        }
-        else if (this.recorderType === "mesio") {
-            return this.videoFormat;
-        }
-        else if (this.recorderType === "bililive") {
-            return "flv";
-        }
-        else {
-            throw new Error("Unknown recorderType");
-        }
+        return this.videoFormat;
     }
     get videoFilePath() {
         if (this.recorderType === "ffmpeg") {

package/lib/index.d.ts

@@ -6,9 +6,11 @@ import utils from "./utils.js";
 export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
+export * from "./cache.js";
 export * from "./record_extra_data_controller.js";
-export * from "./recorder/FFMPEGRecorder.js";
-export { createBaseRecorder } from "./recorder/index.js";
+export * from "./downloader/FFmpegDownloader.js";
+export { createDownloader } from "./downloader/index.js";
+export { checkTitleKeywordsWhileRecording, checkTitleKeywordsBeforeRecord } from "./utils.js";
 export { utils };
 /**
  * 提供一些 utils
@@ -25,3 +27,4 @@ export declare function setBililivePath(newPath: string): void;
 export declare function getBililivePath(): string;
 export declare function getDataFolderPath<E extends AnyObject>(provider: RecorderProvider<E>): string;
 export type VideoFormat = "auto" | "ts" | "mkv" | "flv" | "mp4" | "m4s";
+export type TrueVideoFormat = Exclude<VideoFormat, "auto">;

package/lib/index.js

@@ -5,9 +5,11 @@ import utils from "./utils.js";
 export * from "./common.js";
 export * from "./recorder.js";
 export * from "./manager.js";
+export * from "./cache.js";
 export * from "./record_extra_data_controller.js";
-export * from "./recorder/FFMPEGRecorder.js";
-export { createBaseRecorder } from "./recorder/index.js";
+export * from "./downloader/FFmpegDownloader.js";
+export { createDownloader } from "./downloader/index.js";
+export { checkTitleKeywordsWhileRecording, checkTitleKeywordsBeforeRecord } from "./utils.js";
 export { utils };
 /**
  * 提供一些 utils

package/lib/manager.d.ts

@@ -1,9 +1,9 @@
 import { Emitter } from "mitt";
 import { ChannelId, Message } from "./common.js";
+import { RecorderCache } from "./cache.js";
 import { RecorderCreateOpts, Recorder, SerializedRecorder, RecordHandle, DebugLog, Progress } from "./recorder.js";
 import { AnyObject, UnknownObject } from "./utils.js";
-import { StreamManager } from "./recorder/streamManager.js";
-import { Cache } from "./cache.js";
+import { StreamManager } from "./downloader/streamManager.js";
 export interface RecorderProvider<E extends AnyObject> {
     id: string;
     name: string;
@@ -75,8 +75,9 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     providers: P[];
     getChannelURLMatchedRecorderProviders: (this: RecorderManager<ME, P, PE, E>, channelURL: string) => P[];
     recorders: Recorder<E>[];
-    addRecorder: (this: RecorderManager<ME, P, PE, E>, opts: Omit<RecorderCreateOpts<E>, "cache">) => Recorder<E>;
+    addRecorder: (this: RecorderManager<ME, P, PE, E>, opts: RecorderCreateOpts<E>) => Recorder<E>;
     removeRecorder: (this: RecorderManager<ME, P, PE, E>, recorder: Recorder<E>) => void;
+    getRecorder: (this: RecorderManager<ME, P, PE, E>, id: string) => Recorder<E> | null;
     startRecord: (this: RecorderManager<ME, P, PE, E>, id: string) => Promise<Recorder<E> | undefined>;
     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>;
@@ -91,13 +92,15 @@ export interface RecorderManager<ME extends UnknownObject, P extends RecorderPro
     ffmpegOutputArgs: string;
     /** b站使用批量查询接口 */
     biliBatchQuery: boolean;
-    /** 测试：录制错误立即重试 */
+    /** 下播延迟检查 */
     recordRetryImmediately: boolean;
-    /** 缓存实例 */
-    cache: Cache;
+    /** 缓存系统 */
+    cache: RecorderCache;
 }
 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;
 };
 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: {
@@ -108,4 +111,4 @@ export declare function genSavePathFromRule<ME extends AnyObject, P extends Reco
     recordStartTime: Date;
 }): string;
 export type GetProviderExtra<P> = P extends RecorderProvider<infer E> ? E : never;
-export { StreamManager, Cache };
+export { StreamManager };

package/lib/manager.js

@@ -3,10 +3,10 @@ import mitt from "mitt";
 import ejs from "ejs";
 import { omit, range } from "lodash-es";
 import { parseArgsStringToArgv } from "string-argv";
+import { RecorderCacheImpl, MemoryCacheStore } from "./cache.js";
 import { getBiliStatusInfoByRoomIds } from "./api.js";
 import { formatDate, removeSystemReservedChars, formatTemplate, replaceExtName, downloadImage, isBetweenTimeRange, sleep, } from "./utils.js";
-import { StreamManager } from "./recorder/streamManager.js";
-import { Cache } from "./cache.js";
+import { StreamManager } from "./downloader/streamManager.js";
 const configurableProps = [
     "savePathRule",
     "autoRemoveSystemReservedChars",
@@ -97,8 +97,6 @@ export function createRecorderManager(opts) {
     const liveStartObj = {};
     // 用于记录触发重试直播场次的次数
     const retryCountObj = {};
-    // 获取缓存单例
-    const cache = Cache.getInstance();
     const manager = {
         // @ts-ignore
         ...mitt(),
@@ -115,8 +113,10 @@ export function createRecorderManager(opts) {
             // provider.createRecorder 能返回 Recorder<PE> 才能进一步优化。
             const recorder = provider.createRecorder({
                 ...omit(opts, ["providerId"]),
-                cache,
+                // cache,
             });
+            // 为录制器注入独立的缓存命名空间
+            recorder.cache = this.cache.createNamespace(recorder.id);
             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 }));
@@ -133,29 +133,32 @@ export function createRecorderManager(opts) {
             recorder.on("DebugLog", (log) => this.emit("RecorderDebugLog", { recorder: recorder, ...log }));
             recorder.on("RecordStop", ({ recordHandle, reason }) => {
                 this.emit("RecordStop", { recorder: recorder.toJSON(), recordHandle, reason });
-                // 如果reason中存在"invalid stream"，说明直播由于某些原因中断了，虽然会在下一次周期检查中继续，但是会遗漏一段时间。
-                // 这时候可以触发一次检查，但出于直播可能抽风的原因，为避免风控，一场直播最多触发五次。
-                // 测试阶段，还需要一个开关，默认关闭，几个版本后转正使用
+                const maxRetryCount = 10;
+                // 默认策略下，如果录制被中断，那么会在下一个检查周期时重新检查直播状态并重新开始录制，这种策略的问题就是一部分时间会被漏掉。
+                // 如果开启了该选项，且录制开始时间与结束时间相差在一分钟以上（某些平台下播会扔会有重复流），那么会立即进行一次检查。
                 // 也许之后还能链接复用，但也会引入更多复杂度，需要谨慎考虑
                 // 虎牙直播结束后可能额外触发导致错误，忽略虎牙直播间：https://www.huya.com/910323
                 if (manager.recordRetryImmediately &&
-                    recorder.providerId !== "HuYa" &&
-                    reason &&
-                    reason.includes("invalid stream") &&
-                    recorder?.liveInfo?.liveId) {
+                    recorder?.liveInfo?.liveId &&
+                    reason !== "manual stop") {
                     const key = `${recorder.channelId}-${recorder.liveInfo?.liveId}`;
-                    if (retryCountObj[key] > 5)
+                    const recordStartTime = recorder.liveInfo?.recordStartTime.getTime() ?? 0;
+                    const recordStopTime = Date.now();
+                    // 录制时间差在一分钟以上
+                    if (recordStopTime - recordStartTime < 60 * 1000)
+                        return;
+                    if (retryCountObj[key] > maxRetryCount)
                         return;
                     if (!retryCountObj[key]) {
                         retryCountObj[key] = 0;
                     }
-                    if (retryCountObj[key] < 5) {
+                    if (retryCountObj[key] < maxRetryCount) {
                         retryCountObj[key]++;
                     }
                     this.emit("RecorderDebugLog", {
                         recorder,
                         type: "common",
-                        text: `录制${recorder?.channelId}因“${reason}”中断，触发重试直播（${retryCountObj[key]}）`,
+                        text: `录制${recorder.channelId}中断，立即触发重试（${retryCountObj[key]}/${maxRetryCount}）`,
                     });
                     // 触发一次检查，等待一秒使状态清理完毕
                     setTimeout(() => {
@@ -191,6 +194,10 @@ export function createRecorderManager(opts) {
             delete tempBanObj[recorder.channelId];
             this.emit("RecorderRemoved", recorder.toJSON());
         },
+        getRecorder(id) {
+            const recorder = this.recorders.find((item) => item.id === id);
+            return recorder ?? null;
+        },
         async startRecord(id) {
             const recorder = this.recorders.find((item) => item.id === id);
             if (recorder == null)
@@ -214,7 +221,7 @@ export function createRecorderManager(opts) {
             if (recorder.recordHandle == null)
                 return;
             const liveId = recorder.liveInfo?.liveId;
-            await recorder.recordHandle.stop("manual stop", true);
+            await recorder.recordHandle.stop("manual stop");
             if (liveId) {
                 tempBanObj[recorder.channelId] = liveId;
                 recorder.tempStopIntervalCheck = true;
@@ -269,6 +276,7 @@ export function createRecorderManager(opts) {
         autoRemoveSystemReservedChars: opts.autoRemoveSystemReservedChars ?? true,
         biliBatchQuery: opts.biliBatchQuery ?? false,
         recordRetryImmediately: opts.recordRetryImmediately ?? false,
+        cache: opts.cache ?? new RecorderCacheImpl(new MemoryCacheStore()),
         ffmpegOutputArgs: opts.ffmpegOutputArgs ??
             "-c copy" +
                 /**
@@ -276,18 +284,7 @@ export function createRecorderManager(opts) {
                  * 最后一个片段，而 FLV 格式如果录制中 KILL 了需要手动修复下 keyframes。所以默认使用 fmp4 格式。
                  */
                 " -movflags faststart+frag_keyframe+empty_moov" +
-                /**
-                 * 浏览器加载 FragmentMP4 会需要先把它所有的 moof boxes 都加载完成后才能播放，
-                 * 默认的分段时长很小，会产生大量的 moof，导致加载很慢，所以这里设置一个分段的最小时长。
-                 *
-                 * TODO: 这个浏览器行为或许是可以优化的，比如试试给 fmp4 在录制完成后设置或者录制过程中实时更新 mvhd.duration。
-                 * https://stackoverflow.com/questions/55887980/how-to-use-media-source-extension-mse-low-latency-mode
-                 * https://stackoverflow.com/questions/61803136/ffmpeg-fragmented-mp4-takes-long-time-to-start-playing-on-chrome
-                 *
-                 * TODO: 如果浏览器行为无法优化，并且想进一步优化加载速度，可以考虑录制时使用 fmp4，录制完成后再转一次普通 mp4。
-                 */
                 " -min_frag_duration 10000000",
-        cache,
     };
     const setProvidersFFMPEGOutputArgs = (ffmpegOutputArgs) => {
         const args = parseArgsStringToArgv(ffmpegOutputArgs);
@@ -334,11 +331,10 @@ export function genSavePathFromRule(manager, recorder, extData) {
     let savePathRule = manager.savePathRule;
     try {
         savePathRule = ejs.render(savePathRule, params);
-        console.log("解析后保存路径模板：", savePathRule, params);
     }
     catch (error) {
         console.error("模板解析错误", error, savePathRule, params);
     }
     return formatTemplate(savePathRule, params);
 }
-export { StreamManager, Cache };
+export { StreamManager };

package/lib/record_extra_data_controller.d.ts

@@ -5,7 +5,7 @@ export interface RecordExtraData {
         recordStartTimestamp: number;
         recordStopTimestamp?: number;
         liveStartTimestamp?: number;
-        ffmpegArgs?: string[];
+        downloaderArgs?: string[];
         platform?: string;
         user_name?: string;
         room_id?: string;

package/lib/recorder.d.ts

@@ -2,8 +2,8 @@ import { Emitter } from "mitt";
 import { ChannelId, Message, Quality } from "./common.js";
 import { RecorderProvider } from "./manager.js";
 import { AnyObject, PickRequired, UnknownObject } from "./utils.js";
-import { Cache } from "./cache.js";
-import type { RecorderType } from "./recorder/index.js";
+import type { NamespacedCache } from "./cache.js";
+import type { DownloaderType } from "./downloader/index.js";
 type FormatName = "auto" | "flv" | "hls" | "fmp4" | "flv_only" | "hls_only" | "fmp4_only";
 type CodecName = "auto" | "avc" | "hevc" | "avc_only" | "hevc_only";
 export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
@@ -19,7 +19,7 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     sourcePriorities: string[];
     formatPriorities?: Array<"flv" | "hls">;
     source?: string;
-    segment?: number;
+    segment?: string;
     saveGiftDanma?: boolean;
     saveSCDanma?: boolean;
     /** 保存封面 */
@@ -40,8 +40,8 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     formatName?: FormatName;
     /** 流编码 */
     codecName?: CodecName;
-    /** 选择使用的api，虎牙支持: auto,web,mp，抖音支持：web,webHTML,mobile,userHTML */
-    api?: "auto" | "web" | "mp" | "webHTML" | "mobile" | "userHTML";
+    /** 选择使用的api，虎牙支持: auto,web,mp,wup，抖音支持：web,webHTML,mobile,userHTML */
+    api?: "auto" | "web" | "mp" | "wup" | "webHTML" | "mobile" | "userHTML" | "balance" | "random" | string;
     /** 标题关键词，如果直播间标题包含这些关键词，则不会自动录制（仅对斗鱼有效），多个关键词用英文逗号分隔 */
     titleKeywords?: string;
     /** 用于指定录制文件格式，auto时，分段使用ts，不分段使用mp4 */
@@ -59,8 +59,6 @@ export interface RecorderCreateOpts<E extends AnyObject = UnknownObject> {
     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">;
 /** 录制状态，idle: 空闲中，recording: 录制中，stopping-record: 停止录制中，check-error: 检查错误，title-blocked: 标题黑名单 */
@@ -72,12 +70,12 @@ export interface RecordHandle {
     id: string;
     stream: string;
     source: string;
-    recorderType?: RecorderType;
+    recorderType?: DownloaderType;
     url: string;
-    ffmpegArgs?: string[];
+    downloaderArgs?: string[];
     progress?: Progress;
     savePath: string;
-    stop: (this: RecordHandle, reason?: string, tempStopIntervalCheck?: boolean) => Promise<void>;
+    stop: (this: RecordHandle, reason?: string) => Promise<void>;
     cut: (this: RecordHandle) => Promise<void>;
 }
 export interface DebugLog {
@@ -118,21 +116,21 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
     usedStream?: string;
     usedSource?: string;
     state: RecorderState;
-    qualityMaxRetry: number;
     qualityRetry: number;
     uid?: number | string;
     liveInfo?: {
         living: boolean;
         owner: string;
         title: string;
-        startTime: Date;
+        liveStartTime: Date;
         avatar: string;
         cover: string;
         liveId?: string;
+        recordStartTime: Date;
     };
     tempStopIntervalCheck?: boolean;
-    /** 缓存实例引用，由 manager 设置 */
-    cache: Cache;
+    /** 缓存实例（命名空间） */
+    cache: NamespacedCache;
     getChannelURL: (this: Recorder<E>) => string;
     checkLiveStatusAndRecord: (this: Recorder<E>, opts: {
         getSavePath: GetSavePath;
@@ -148,7 +146,7 @@ export interface Recorder<E extends AnyObject = UnknownObject> extends Emitter<{
         cover: string;
         channelId: ChannelId;
         living: boolean;
-        startTime: Date;
+        liveStartTime: Date;
     }>;
     getStream: (this: Recorder<E>) => Promise<{
         source: string;

package/lib/utils.d.ts

@@ -1,4 +1,5 @@
 import { DebouncedFunc } from "lodash-es";
+import type { Recorder } from "./recorder.js";
 export type AnyObject = Record<string, any>;
 export type UnknownObject = Record<string, unknown>;
 export type PickRequired<T, K extends keyof T> = T & Pick<Required<T>, K>;
@@ -74,6 +75,14 @@ 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>;
+/**
+ * 判断是否应该使用严格画质模式
+ * @param qualityRetryLeft 剩余的画质重试次数
+ * @param qualityRetry 初始画质重试次数配置
+ * @param isManualStart 是否手动启动
+ * @returns 是否使用严格画质模式
+ */
+export declare function shouldUseStrictQuality(qualityRetryLeft: number, qualityRetry: number, isManualStart?: boolean): boolean;
 /**
  * 检查标题是否包含黑名单关键词
  */
@@ -82,6 +91,24 @@ declare function hasBlockedTitleKeywords(title: string, titleKeywords: string |
  * 检查是否需要进行标题关键词检查
  */
 declare function shouldCheckTitleKeywords(isManualStart: boolean | undefined, titleKeywords: string | undefined): boolean;
+/**
+ * 逆向格式化"xxxB", "xxxKB", "xxxMB", "xxxGB"为字节数，如果值为空返回0，如果为数字则直接返回数字，如果带单位则转换为字节数
+ * @param sizeStr 大小字符串
+ * @returns 字节数
+ */
+export declare function parseSizeToBytes(sizeStr: string): number | string;
+export declare const byte2MB: (bytes: number) => number;
+export declare function checkTitleKeywordsWhileRecording(recorder: Recorder, isManualStart: boolean | undefined, getInfo: (channelId: string) => Promise<{
+    title: string;
+}>): Promise<boolean>;
+/**
+ * 检查开始录制前的标题关键词
+ * @param title 直播间标题
+ * @param recorder 录制器实例
+ * @param isManualStart 是否手动启动
+ * @returns 如果标题包含关键词返回 true（不应录制），否则返回 false
+ */
+export declare function checkTitleKeywordsBeforeRecord(title: string, recorder: Recorder, isManualStart: boolean | undefined): boolean;
 declare const _default: {
     replaceExtName: typeof replaceExtName;
     singleton: typeof singleton;
@@ -103,6 +130,9 @@ declare const _default: {
     isBetweenTimeRange: (range: undefined | [] | [string | null, string | null]) => boolean;
     hasBlockedTitleKeywords: typeof hasBlockedTitleKeywords;
     shouldCheckTitleKeywords: typeof shouldCheckTitleKeywords;
+    shouldUseStrictQuality: typeof shouldUseStrictQuality;
     sleep: (ms: number) => Promise<unknown>;
+    checkTitleKeywordsWhileRecording: typeof checkTitleKeywordsWhileRecording;
+    checkTitleKeywordsBeforeRecord: typeof checkTitleKeywordsBeforeRecord;
 };
 export default _default;