@bililive-tools/manager 1.8.0 → 1.10.0

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>;
@@ -34,7 +35,7 @@ export declare function assertStringType(data: unknown, msg?: string): asserts d
 export declare function assertNumberType(data: unknown, msg?: string): asserts data is number;
 export declare function assertObjectType(data: unknown, msg?: string): asserts data is object;
 export declare function formatDate(date: Date, format: string): string;
-export declare function removeSystemReservedChars(filename: string): string;
+export declare function removeSystemReservedChars(str: string): string;
 export declare function isFfmpegStartSegment(line: string): boolean;
 export declare function isMesioStartSegment(line: string): boolean;
 export declare function isBililiveStartSegment(line: string): boolean;
@@ -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;

package/lib/utils.js

@@ -120,8 +120,8 @@ export function formatDate(date, format) {
     };
     return format.replace(/yyyy|MM|dd|HH|mm|ss/g, (matched) => map[matched]);
 }
-export function removeSystemReservedChars(filename) {
-    return filenamify(filename, { replacement: "_" });
+export function removeSystemReservedChars(str) {
+    return filenamify(str, { replacement: "_" });
 }
 export function isFfmpegStartSegment(line) {
     return line.includes("Opening ") && line.includes("for writing");
@@ -327,6 +327,32 @@ function isBetweenTime(currentTime, timeRange) {
     return start <= current && current <= end;
 }
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/**
+ * 判断是否应该使用严格画质模式
+ * @param qualityRetryLeft 剩余的画质重试次数
+ * @param qualityRetry 初始画质重试次数配置
+ * @param isManualStart 是否手动启动
+ * @returns 是否使用严格画质模式
+ */
+export function shouldUseStrictQuality(qualityRetryLeft, qualityRetry, isManualStart) {
+    // 手动启动时不使用严格模式
+    if (isManualStart) {
+        return false;
+    }
+    // 如果配置为0，不使用严格模式
+    if (qualityRetry === 0) {
+        return false;
+    }
+    // 如果还有重试次数，使用严格模式
+    if (qualityRetryLeft > 0) {
+        return true;
+    }
+    // 如果配置为负数（无限重试），使用严格模式
+    if (qualityRetry < 0) {
+        return true;
+    }
+    return false;
+}
 /**
  * 检查标题是否包含黑名单关键词
  */
@@ -343,6 +369,106 @@ function hasBlockedTitleKeywords(title, titleKeywords) {
 function shouldCheckTitleKeywords(isManualStart, titleKeywords) {
     return (!isManualStart && !!titleKeywords && typeof titleKeywords === "string" && !!titleKeywords.trim());
 }
+/**
+ * 逆向格式化"xxxB", "xxxKB", "xxxMB", "xxxGB"为字节数，如果值为空返回0，如果为数字则直接返回数字，如果带单位则转换为字节数
+ * @param sizeStr 大小字符串
+ * @returns 字节数
+ */
+export function parseSizeToBytes(sizeStr) {
+    if (!sizeStr) {
+        return 0;
+    }
+    // 字符类型的数字
+    if (!isNaN(Number(sizeStr))) {
+        return Number(sizeStr);
+    }
+    const sizePattern = /^(\d+(?:\.\d+)?)(B|KB|MB|GB)$/i;
+    const match = sizeStr.toUpperCase().trim().match(sizePattern);
+    if (match) {
+        const size = parseFloat(match[1]);
+        const unit = match[2];
+        switch (unit) {
+            case "B":
+                return String(size);
+            case "KB":
+                return String(size * 1024);
+            case "MB":
+                return String(size * 1024 * 1024);
+            case "GB":
+                return String(size * 1024 * 1024 * 1024);
+            default:
+                return 0;
+        }
+    }
+    else {
+        return 0;
+    }
+}
+export const byte2MB = (bytes) => {
+    return bytes / (1024 * 1024);
+};
+/*
+ * 检查录制中的标题关键词
+ * @param recorder 录制器实例
+ * @param isManualStart 是否手动启动
+ * @param getInfo 获取直播间信息的函数
+ * @returns 如果标题包含关键词返回 true（需要停止），否则返回 false
+ */
+export async function checkTitleKeywordsWhileRecording(recorder, isManualStart, getInfo) {
+    // 只有当设置了标题关键词时，并且不是手动启动的录制，才获取最新的直播间信息
+    if (!shouldCheckTitleKeywords(isManualStart, recorder.titleKeywords)) {
+        return false;
+    }
+    const now = Date.now();
+    // 每5分钟检查一次标题变化
+    const titleCheckInterval = 5 * 60 * 1000; // 5分钟
+    // 获取上次检查时间
+    const lastCheckTime = await recorder.cache.get("lastTitleCheckTime");
+    // 如果距离上次检查时间不足指定间隔，则跳过检查
+    if (lastCheckTime && now - lastCheckTime < titleCheckInterval) {
+        return false;
+    }
+    // 更新检查时间
+    await recorder.cache.set("lastTitleCheckTime", now);
+    // 获取直播间信息
+    const liveInfo = await getInfo(recorder.channelId);
+    const { title } = liveInfo;
+    // 检查标题是否包含关键词
+    if (hasBlockedTitleKeywords(title, recorder.titleKeywords)) {
+        recorder.state = "title-blocked";
+        recorder.emit("DebugLog", {
+            type: "common",
+            text: `检测到标题包含关键词，停止录制：直播间标题 "${title}" 包含关键词 "${recorder.titleKeywords}"`,
+        });
+        // 停止录制
+        await recorder?.recordHandle?.stop("直播间标题包含关键词");
+        return true;
+    }
+    return false;
+}
+/**
+ * 检查开始录制前的标题关键词
+ * @param title 直播间标题
+ * @param recorder 录制器实例
+ * @param isManualStart 是否手动启动
+ * @returns 如果标题包含关键词返回 true（不应录制），否则返回 false
+ */
+export function checkTitleKeywordsBeforeRecord(title, recorder, isManualStart) {
+    // 检查标题是否包含关键词，如果包含则不自动录制
+    // 手动开始录制时不检查标题关键词
+    if (!shouldCheckTitleKeywords(isManualStart, recorder.titleKeywords)) {
+        return false;
+    }
+    if (hasBlockedTitleKeywords(title, recorder.titleKeywords)) {
+        recorder.state = "title-blocked";
+        recorder.emit("DebugLog", {
+            type: "common",
+            text: `跳过录制：直播间标题 "${title}" 包含关键词 "${recorder.titleKeywords}"`,
+        });
+        return true;
+    }
+    return false;
+}
 export default {
     replaceExtName,
     singleton,
@@ -364,5 +490,8 @@ export default {
     isBetweenTimeRange,
     hasBlockedTitleKeywords,
     shouldCheckTitleKeywords,
+    shouldUseStrictQuality,
     sleep,
+    checkTitleKeywordsWhileRecording,
+    checkTitleKeywordsBeforeRecord,
 };

package/lib/xml_stream_controller.d.ts

@@ -5,7 +5,7 @@ export interface XmlStreamData {
         recordStartTimestamp: number;
         recordStopTimestamp?: number;
         liveStartTimestamp?: number;
-        ffmpegArgs?: string[];
+        downloaderArgs?: string[];
         platform?: string;
         user_name?: string;
         room_id?: string;
@@ -17,7 +17,7 @@ export interface XmlStreamController {
     /** 设计上来说，外部程序不应该能直接修改 data 上的东西 */
     readonly data: XmlStreamData;
     addMessage: (message: Message) => void;
-    setMeta: (meta: Partial<XmlStreamData["meta"]>) => void;
+    setMeta: (meta: Partial<XmlStreamData["meta"]>) => Promise<void>;
     flush: () => Promise<void>;
 }
 export declare function createRecordExtraDataController(savePath: string): XmlStreamController;

package/lib/xml_stream_controller.js

@@ -70,13 +70,16 @@ export function createRecordExtraDataController(savePath) {
         initializeFile().catch(console.error);
         scheduleWrite();
     };
-    const setMeta = (meta) => {
+    const setMeta = async (meta) => {
         if (hasCompleted)
             return;
         data.meta = {
             ...data.meta,
             ...meta,
         };
+        // 确保文件已初始化，然后立即更新文件中的metadata
+        await initializeFile().catch(console.error);
+        await updateMetadataInFile(savePath, data.meta).catch(console.error);
     };
     const flush = async () => {
         if (hasCompleted)
@@ -89,7 +92,7 @@ export function createRecordExtraDataController(savePath) {
             await writeToFile();
         }
         // 完成XML文件（添加结束标签等）
-        await finalizeXmlFile(savePath, data.meta);
+        await finalizeXmlFile(savePath);
         // 清理内存
         data.pendingMessages = [];
     };
@@ -206,9 +209,9 @@ async function appendToXmlFile(filePath, content) {
     }
 }
 /**
- * 完成XML文件写入
+ * 更新XML文件中的metadata
  */
-async function finalizeXmlFile(filePath, metadata) {
+async function updateMetadataInFile(filePath, metadata) {
     try {
         const builder = new XMLBuilder({
             ignoreAttributes: false,
@@ -228,8 +231,25 @@ async function finalizeXmlFile(filePath, metadata) {
         });
         // 读取文件内容
         const content = await fs.promises.readFile(filePath, "utf-8");
-        // 替换占位符为实际的metadata，并添加结束标签
-        const finalContent = content.replace("<!--METADATA_PLACEHOLDER-->", metadataXml) + "</i>";
+        // 替换占位符为实际的metadata
+        const updatedContent = content.replace("<!--METADATA_PLACEHOLDER-->", metadataXml);
+        // 写回文件
+        await fs.promises.writeFile(filePath, updatedContent);
+    }
+    catch (error) {
+        console.error(`更新XML文件metadata失败: ${filePath}`, error);
+        throw error;
+    }
+}
+/**
+ * 完成XML文件写入
+ */
+async function finalizeXmlFile(filePath) {
+    try {
+        // 读取文件内容
+        const content = await fs.promises.readFile(filePath, "utf-8");
+        // 添加结束标签
+        const finalContent = content + "</i>";
         // 写回文件
         await fs.promises.writeFile(filePath, finalContent);
     }

package/package.json

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

package/lib/recorder/index.d.ts

@@ -1,48 +0,0 @@
-import { FFMPEGRecorder } from "./FFMPEGRecorder.js";
-import { MesioRecorder } from "./mesioRecorder.js";
-import { BililiveRecorder } from "./BililiveRecorder.js";
-export { FFMPEGRecorder } from "./FFMPEGRecorder.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" | "bililive";
-export type FormatName = "flv" | "ts" | "fmp4";
-/**
- * 根据录制器类型获取对应的配置选项类型
- */
-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 : T extends "mesio" ? MesioRecorder : BililiveRecorder;
-type RecorderOpts = FFMPEGRecorderOptions | MesioRecorderOptions | BililiveRecorderOptions;
-/**
- * 创建录制器的工厂函数
- */
-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;
-}>): IRecorder;