bililive-cli 3.8.2 → 3.9.0

package/lib/{index-9RtWxDCO.cjs → index-Ba32bNTL.cjs}

@@ -11533,9 +11533,37 @@ const APP_DEFAULT_CONFIG = {
     },
     llmPresets: [],
     ai: {
-        vendors: [],
+        vendors: [
+            {
+                id: "3d09badd-5402-4b80-9113-48c0739d51b9",
+                name: "阿里云",
+                provider: "aliyun",
+                apiKey: "",
+            },
+        ],
+        models: [
+            {
+                vendorId: "3d09badd-5402-4b80-9113-48c0739d51b9",
+                modelId: "116497be-e650-4b21-8769-536859cb16dc",
+                modelName: "fun-asr",
+                remark: "语音识别",
+                tags: ["asr"],
+                config: {},
+            },
+            {
+                vendorId: "3d09badd-5402-4b80-9113-48c0739d51b9",
+                modelId: "ca277547-fabd-462b-99d2-cf76f56002e6",
+                modelName: "qwen-plus",
+                remark: "通用大模型",
+                tags: ["llm"],
+                config: {},
+            },
+        ],
+        songRecognizeAsr: {
+            modelId: "",
+        },
         songRecognizeLlm: {
-            vendorId: undefined,
+            modelId: "",
             prompt: `
 你是一个极度专业的音乐识别专家，擅长从存在误差的 ASR（语音识别）文本中提取核心语义，并精准锁定歌曲信息。
 从搜索结果中精确获取歌名以及需确保返回的【歌词】版本为官方标准发行版，不要遗漏，请提供【歌词】
@@ -11545,14 +11573,13 @@ const APP_DEFAULT_CONFIG = {
   "lyrics": "[查询到的完整标准歌词]",
   "name": "[准确的歌曲名称]"
 }`,
-            model: "qwen-plus",
             enableSearch: true,
             maxInputLength: 300,
             enableStructuredOutput: true,
             lyricOptimize: true,
         },
         songLyricOptimize: {
-            vendorId: undefined,
+            modelId: "",
             prompt: `
 # Role
 你是一个极度严谨的音频字幕对齐专家，擅长将破碎的 ASR 识别结果（ASR_Data）完美映射到标准文本（Standard_Lyrics）上。
@@ -11581,9 +11608,11 @@ const APP_DEFAULT_CONFIG = {
 ## Output Format
 仅输出 JSON 对象，格式如下： {"data": [{"st": 123, "et": 456, "t": "标准歌词内容"}]}
 `,
-            model: "",
             enableStructuredOutput: true,
         },
+        subtitleRecognize: {
+            modelId: "",
+        },
     },
     biliUpload: {
         line: "auto",
@@ -11617,7 +11646,7 @@ const APP_DEFAULT_CONFIG = {
         qualityRetry: 0,
         videoFormat: "auto",
         recorderType: "bililive",
-        useServerTimestamp: true,
+        useServerTimestamp: false,
         recordRetryImmediately: true,
         bilibili: {
             uid: undefined,
@@ -12045,7 +12074,7 @@ const defaultRecordConfig = {
     recorderType: "ffmpeg",
     cookie: "",
     doubleScreen: true,
-    useServerTimestamp: true,
+    useServerTimestamp: false,
     handleTime: [null, null],
     debugLevel: "none",
     api: "web",
@@ -12348,7 +12377,7 @@ const DEFAULT_BILIUP_CONFIG = {
     dynamic: "",
     cover: "",
     noReprint: 0,
-    watermark: 1,
+    watermark: 0,
     openElec: 0,
     closeDanmu: 0,
     closeReply: 0,
@@ -44431,7 +44460,7 @@ async function trash(paths, options) {
 	} else if (process$2.platform === 'win32') {
 		module = await Promise.resolve().then(function () { return require('./windows-CJCw0QtL.cjs'); });
 	} else {
-		module = await Promise.resolve().then(function () { return require('./linux-DXOcGMTy.cjs'); });
+		module = await Promise.resolve().then(function () { return require('./linux-v9dbfGoh.cjs'); });
 	}
 
 	return module.default(paths);
@@ -57500,6 +57529,9 @@ class Platform extends BaseRequest {
             ...archiveData,
             csrf: csrf,
             ...options,
+            watermark: {
+                state: options.watermark?.state ?? archive.watermark.state,
+            },
         };
         this.checkOptions(data);
         data.aid = Number(data.aid);
@@ -178148,6 +178180,10 @@ class RecordHistoryModel extends BaseModel {
                     name: "idx_record_history_live_video",
                     sql: `CREATE INDEX IF NOT EXISTS idx_record_history_live_video ON record_history(live_id, video_file)`,
                 },
+                {
+                    name: "idx_record_history_record_start_time",
+                    sql: `CREATE INDEX IF NOT EXISTS idx_record_history_record_start_time ON record_history(record_start_time)`,
+                },
             ];
             for (const index of indexes) {
                 if (!this.checkIndexExists(index.name)) {
@@ -178283,6 +178319,41 @@ class RecordHistoryModel extends BaseModel {
         const data = dataStmt.all(...params, pageSize, offset);
         return { data, total };
     }
+    /**
+     * 查询总视频时长
+     * @param options 查询参数
+     * @returns 总时长（秒）
+     */
+    getTotalDuration(options) {
+        const { streamerId, startTime, endTime } = options || {};
+        // 构建WHERE条件
+        const whereConditions = [];
+        const params = [];
+        // 过滤掉 video_duration 为 null 或 0 的记录
+        whereConditions.push("video_duration IS NOT NULL");
+        whereConditions.push("video_duration > 0");
+        if (streamerId) {
+            whereConditions.push("streamer_id = ?");
+            params.push(streamerId);
+        }
+        if (startTime) {
+            whereConditions.push("record_start_time >= ?");
+            params.push(startTime);
+        }
+        if (endTime) {
+            whereConditions.push("record_start_time <= ?");
+            params.push(endTime);
+        }
+        const whereClause = `WHERE ${whereConditions.join(" AND ")}`;
+        const sql = `
+      SELECT COALESCE(SUM(video_duration), 0) as total_duration
+      FROM ${this.tableName}
+      ${whereClause}
+    `;
+        const stmt = this.db.prepare(sql);
+        const result = stmt.get(...params);
+        return result.total_duration || 0;
+    }
 }
 
 const BaseUploadPart = z.object({
@@ -178590,6 +178661,21 @@ class RecordHistoryService {
     getLastRecordTimes(streamerIds) {
         return this.recordHistoryModel.getLastRecordTimes(streamerIds);
     }
+    /**
+     * 查询总视频时长，默认查询最近一个月
+     * @param options 查询参数
+     * @returns 总时长（秒）
+     */
+    getTotalDuration(options) {
+        const now = Math.floor(Date.now() / 1000);
+        const oneMonthAgo = now - 30 * 24 * 60 * 60; // 30天前的时间戳
+        const queryOptions = {
+            streamerId: options?.streamerId,
+            startTime: options?.startTime ?? oneMonthAgo,
+            endTime: options?.endTime ?? now,
+        };
+        return this.recordHistoryModel.getTotalDuration(queryOptions);
+    }
 }
 
 class UploadPartService {
@@ -178905,7 +178991,7 @@ let virtualRecordService;
 let videoSubDataService;
 let streamerService;
 let videoSubService;
-let recordHistoryService;
+exports.recordHistoryService = void 0;
 let uploadPartService;
 let danmuService;
 const initDB = (dbRootPath) => {
@@ -178937,7 +179023,7 @@ const setExportServices = (dbContainer) => {
     videoSubDataService = dbContainer.resolve("videoSubDataService");
     streamerService = dbContainer.resolve("streamerService");
     videoSubService = dbContainer.resolve("videoSubService");
-    recordHistoryService = dbContainer.resolve("recordHistoryService");
+    exports.recordHistoryService = dbContainer.resolve("recordHistoryService");
     uploadPartService = dbContainer.resolve("uploadPartService");
     danmuService = dbContainer.resolve("danmuService");
 };
@@ -179885,6 +179971,52 @@ class Client {
     }
 }
 
+/**
+ * 目录ID缓存，存储已成功创建的目录路径到fileID的映射
+ * key: remotePath, value: fileID
+ */
+const dirIdCache = new Map();
+/**
+ * 正在进行中的目录创建请求Promise缓存，防止并发重复请求
+ * key: remotePath, value: Promise<fileID>
+ */
+const pendingDirRequests = new Map();
+/**
+ * 获取或创建目录，带Promise去重缓存
+ * @param client 123网盘客户端实例
+ * @param remotePath 远程目录路径
+ * @returns Promise<number> 目录的fileID
+ */
+async function getCachedOrCreateDir(client, remotePath) {
+    // 1. 检查已完成的缓存
+    const cachedId = dirIdCache.get(remotePath);
+    if (cachedId !== undefined) {
+        return cachedId;
+    }
+    // 2. 检查是否有进行中的请求
+    const pendingRequest = pendingDirRequests.get(remotePath);
+    if (pendingRequest) {
+        return pendingRequest;
+    }
+    // 3. 创建新的请求
+    const requestPromise = client
+        .mkdirRecursive(remotePath)
+        .then((fileId) => {
+        // 成功后缓存结果
+        dirIdCache.set(remotePath, fileId);
+        // 从进行中的请求中移除
+        pendingDirRequests.delete(remotePath);
+        return fileId;
+    })
+        .catch((error) => {
+        // 失败时从进行中的请求中移除，不缓存失败结果
+        pendingDirRequests.delete(remotePath);
+        throw error;
+    });
+    // 将Promise存入进行中的请求缓存
+    pendingDirRequests.set(remotePath, requestPromise);
+    return requestPromise;
+}
 /**
  * 123网盘上传类
  * 使用123pan-uploader进行文件上传
@@ -179906,6 +180038,20 @@ class Pan123 extends TypedEmitter {
         this.client = new Client(this.accessToken);
         this.speedCalculator = new SpeedCalculator(3000); // 3秒时间窗口
     }
+    /**
+     * 清理目录缓存
+     * @param path 可选，指定要清理的路径。不传则清空所有缓存
+     */
+    static clearDirCache(path) {
+        if (path) {
+            dirIdCache.delete(path);
+            pendingDirRequests.delete(path);
+        }
+        else {
+            dirIdCache.clear();
+            pendingDirRequests.clear();
+        }
+    }
     /**
      * 检查是否已获取访问令牌
      * @returns boolean 是否已获取访问令牌
@@ -179977,78 +180123,94 @@ class Pan123 extends TypedEmitter {
             this.emit("error", error);
             throw error;
         }
-        try {
-            // 需要获取目标目录的ID
-            let parentFileID = await this.client.mkdirRecursive(this.remotePath);
-            // const fileName = path.basename(localFilePath);
-            this.logger.debug(`123网盘开始上传: ${localFilePath} 到 ${this.remotePath}`);
-            const concurrency = options?.concurrency || 3;
-            const limitRate = this.limitRate / concurrency;
-            // 创建上传实例
-            this.currentUploader = new Uploader(localFilePath, this.accessToken, String(parentFileID), {
-                concurrency: concurrency,
-                retryTimes: options?.retry || 7,
-                retryDelay: 5000,
-                duplicate: options?.policy === "skip" ? 2 : 1, // 1: 覆盖, 2: 跳过
-                limitRate,
-            });
-            // 初始化上传计时
-            const uploadStartTime = Date.now();
-            this.speedCalculator.init(uploadStartTime);
-            // 监听上传进度
-            this.currentUploader.on("progress", (data) => {
-                const percentage = Math.round(data.progress * 10000) / 100;
-                const currentTime = Date.now();
-                // 计算上传速度（MB/s）
-                const speed = this.speedCalculator.calculateSpeed(data.data.loaded, currentTime);
-                this.emit("progress", {
-                    uploaded: this.formatSize(data.data.loaded),
-                    total: this.formatSize(data.data.total),
-                    percentage,
-                    speed,
+        let retryCount = 0;
+        const maxRetries = 1;
+        while (retryCount <= maxRetries) {
+            try {
+                // 如果是重试，清除缓存
+                if (retryCount > 0) {
+                    this.logger.info(`检测到parentFileID不存在，清除缓存并重试 (${retryCount}/${maxRetries})`);
+                    Pan123.clearDirCache(this.remotePath);
+                }
+                // 需要获取目标目录的ID（使用缓存避免并发重复请求）
+                let parentFileID = await getCachedOrCreateDir(this.client, this.remotePath);
+                // const fileName = path.basename(localFilePath);
+                this.logger.debug(`123网盘开始上传: ${localFilePath} 到 ${this.remotePath}`);
+                const concurrency = options?.concurrency || 3;
+                const limitRate = this.limitRate / concurrency;
+                // 创建上传实例
+                this.currentUploader = new Uploader(localFilePath, this.accessToken, String(parentFileID), {
+                    concurrency: concurrency,
+                    retryTimes: options?.retry || 7,
+                    retryDelay: 5000,
+                    duplicate: options?.policy === "skip" ? 2 : 1, // 1: 覆盖, 2: 跳过
+                    limitRate,
                 });
-            });
-            // 监听上传完成
-            this.currentUploader.on("completed", () => {
-                const successMsg = `上传成功: ${localFilePath}`;
-                this.emit("success", successMsg);
-            });
-            // 监听上传错误
-            this.currentUploader.on("error", (error) => {
-                this.logger.error(`上传文件出错: ${error.message}`);
-                this.emit("error", error);
-            });
-            // 监听上传取消
-            this.currentUploader.on("cancel", () => {
-                this.logger.info("上传已取消");
-                this.emit("canceled", "上传已取消");
-            });
-            // 开始上传
-            const result = await this.currentUploader.upload();
-            if (result) {
-                const successMsg = `上传成功: ${localFilePath}`;
-                this.logger.debug(successMsg);
-                this.emit("success", successMsg);
-            }
-            else {
-                throw new Error("上传失败");
+                // 初始化上传计时
+                const uploadStartTime = Date.now();
+                this.speedCalculator.init(uploadStartTime);
+                // 监听上传进度
+                this.currentUploader.on("progress", (data) => {
+                    const percentage = Math.round(data.progress * 10000) / 100;
+                    const currentTime = Date.now();
+                    // 计算上传速度（MB/s）
+                    const speed = this.speedCalculator.calculateSpeed(data.data.loaded, currentTime);
+                    this.emit("progress", {
+                        uploaded: this.formatSize(data.data.loaded),
+                        total: this.formatSize(data.data.total),
+                        percentage,
+                        speed,
+                    });
+                });
+                // 监听上传完成
+                this.currentUploader.on("completed", () => {
+                    const successMsg = `上传成功: ${localFilePath}`;
+                    this.emit("success", successMsg);
+                });
+                // 监听上传错误
+                this.currentUploader.on("error", (error) => {
+                    this.logger.error(`上传文件出错: ${error.message}`);
+                    this.emit("error", error);
+                });
+                // 监听上传取消
+                this.currentUploader.on("cancel", () => {
+                    this.logger.info("上传已取消");
+                    this.emit("canceled", "上传已取消");
+                });
+                // 开始上传
+                const result = await this.currentUploader.upload();
+                if (result) {
+                    const successMsg = `上传成功: ${localFilePath}`;
+                    this.logger.debug(successMsg);
+                    this.emit("success", successMsg);
+                    return; // 成功后直接返回
+                }
+                else {
+                    throw new Error("上传失败");
+                }
             }
-        }
-        catch (error) {
-            if (error.message?.includes("cancel")) {
-                this.logger.info("上传已取消");
-                this.emit("canceled", "上传已取消");
+            catch (error) {
+                if (error.message?.includes("cancel")) {
+                    this.logger.info("上传已取消");
+                    this.emit("canceled", "上传已取消");
+                    throw error;
+                }
+                else if (error.message?.includes("parentFileID不存在") && retryCount < maxRetries) {
+                    // 如果错误消息包含"parentFileID不存在"且还没达到最大重试次数，则重试
+                    retryCount++;
+                    continue;
+                }
+                else {
+                    this.logger.error(`上传文件出错: ${error.message}`);
+                    this.emit("error", error);
+                    throw error;
+                }
             }
-            else {
-                this.logger.error(`上传文件出错: ${error.message}`);
-                this.emit("error", error);
+            finally {
+                this.currentUploader = null;
+                // 重置进度追踪
+                this.speedCalculator.reset();
             }
-            throw error;
-        }
-        finally {
-            this.currentUploader = null;
-            // 重置进度追踪
-            this.speedCalculator.reset();
         }
     }
     /**
@@ -245990,7 +246152,7 @@ function addWithStreamer(data) {
     });
     if (!streamer)
         return null;
-    const live = recordHistoryService.add({
+    const live = exports.recordHistoryService.add({
         title: data.title,
         streamer_id: streamer.id,
         live_start_time: data.live_start_time,
@@ -246001,9 +246163,9 @@ function addWithStreamer(data) {
     return live;
 }
 function upadteLive(query, params) {
-    const live = recordHistoryService.query({ video_file: query.video_file, live_id: query.live_id });
+    const live = exports.recordHistoryService.query({ video_file: query.video_file, live_id: query.live_id });
     if (live) {
-        recordHistoryService.update({
+        exports.recordHistoryService.update({
             id: live.id,
             ...params,
         });
@@ -246029,7 +246191,7 @@ function queryRecordsByRoomAndPlatform(options) {
         };
     }
     // 使用数据库分页而不是内存分页
-    const result = recordHistoryService.paginate({
+    const result = exports.recordHistoryService.paginate({
         where: { streamer_id: streamer.id },
         page,
         pageSize,
@@ -246055,17 +246217,17 @@ async function removeRecords(channelId, providerId) {
     });
     if (!streamer)
         throw new Error("没有找到stream");
-    recordHistoryService.removeRecordsByStreamerId(streamer.id);
+    exports.recordHistoryService.removeRecordsByStreamerId(streamer.id);
     return true;
 }
 function getRecord(data) {
-    return recordHistoryService.query({ video_file: data.file, live_id: data.live_id });
+    return exports.recordHistoryService.query({ video_file: data.file, live_id: data.live_id });
 }
 function getRecordById(id) {
-    return recordHistoryService.query({ id });
+    return exports.recordHistoryService.query({ id });
 }
 function removeRecord(id) {
-    const deletedCount = recordHistoryService.removeRecord(id);
+    const deletedCount = exports.recordHistoryService.removeRecord(id);
     return deletedCount > 0;
 }
 /**
@@ -246091,7 +246253,7 @@ function getLastRecordTimesByChannels(channels) {
     }
     // 批量查询最后录制时间（一次数据库查询）
     const streamerIds = streamers.map((s) => s.id);
-    const lastRecordTimesMap = recordHistoryService.getLastRecordTimes(streamerIds);
+    const lastRecordTimesMap = exports.recordHistoryService.getLastRecordTimes(streamerIds);
     // 构建 streamer 映射表
     const streamerMap = new Map(streamers.map((s) => [`${s.platform}_${s.room_id}`, s.id]));
     return channels.map(({ channelId, providerId }) => {
@@ -246852,6 +247014,7 @@ exports.biliApi = biliApi;
 exports.braces_1 = braces_1;
 exports.burn = burn;
 exports.calculateFileQuickHash = calculateFileQuickHash;
+exports.checkDiskSpace = checkDiskSpace;
 exports.checkMergeVideos = checkMergeVideos;
 exports.cloneDeep = cloneDeep;
 exports.closeDB = closeDB;
@@ -246862,6 +247025,7 @@ exports.cut = cut;
 exports.defaultRecordConfig = defaultRecordConfig;
 exports.douyu = douyu;
 exports.ejs = ejs;
+exports.escaped = escaped;
 exports.executeVirtualRecordConfig = executeVirtualRecordConfig;
 exports.fs = fs$k;
 exports.genTimeData = genTimeData;