bililive-cli 3.8.2 → 3.9.0

package/lib/{index-CWr6rOqY.cjs → index-DTf_Oo8U.cjs}

@@ -4,7 +4,7 @@ var path$7 = require('node:path');
 var http$3 = require('node:http');
 var require$$0$4 = require('node:url');
 var a = require('node:https');
-var index = require('./index-9RtWxDCO.cjs');
+var index = require('./index-Ba32bNTL.cjs');
 var require$$0$5 = require('tty');
 var require$$1$2 = require('util');
 var require$$0$c = require('assert');
@@ -32,6 +32,7 @@ require('node:readline');
 require('@napi-rs/canvas');
 require('better-sqlite3');
 var musicSegmentDetector = require('music-segment-detector');
+var require$$0$e = require('child_process');
 var shazamioCore = require('shazamio-core');
 var require$$1$6 = require('https');
 require('node:dns');
@@ -39,7 +40,6 @@ require('constants');
 require('node:fs/promises');
 require('node:process');
 require('node:util');
-require('child_process');
 require('dns');
 require('tls');
 require('punycode');
@@ -30748,6 +30748,21 @@ async function getRecorders(params) {
         },
     };
 }
+/**
+ * 正在录制中直播间数量
+ * @param recording 是否只计算正在录制的直播间，默认为true
+ * @returns
+ */
+function getRecorderNum(recording) {
+    const recorderManager = exports.container.resolve("recorderManager");
+    const recorders = recorderManager.manager.recorders;
+    if (recording) {
+        return recorders.filter((recorder) => recorder.recordHandle != null).length;
+    }
+    else {
+        return recorders.length;
+    }
+}
 function getRecorder(args) {
     const recorderManager = exports.container.resolve("recorderManager");
     const recorder = recorderManager.manager.recorders.find((item) => item.id === args.id);
@@ -30941,6 +30956,7 @@ async function getLiveInfo(ids) {
 }
 var recorderService = {
     getRecorders,
+    getRecorderNum,
     getRecorder,
     addRecorder,
     updateRecorder,
@@ -56596,6 +56612,18 @@ router$d.get("/appStartTime", async (ctx) => {
     const data = index.statisticsService.query("start_time");
     ctx.body = data?.value;
 });
+router$d.get("/statistics", async (ctx) => {
+    const startTime = index.statisticsService.query("start_time");
+    const videoTotalDuaration = index.recordHistoryService.getTotalDuration();
+    const recordingNum = recorderService.getRecorderNum(true);
+    const recorderNum = recorderService.getRecorderNum(false);
+    ctx.body = {
+        startTime: startTime?.value || null,
+        videoTotalDuaration,
+        recordingNum,
+        recorderNum,
+    };
+});
 router$d.get("/exportLogs", async (ctx) => {
     const logFilePath = exports.config.logPath;
     ctx.body = index.fs.createReadStream(logFilePath);
@@ -57034,6 +57062,47 @@ router$d.get("/tempPath", async (ctx) => {
         ctx.body = "获取缓存路径失败";
     }
 });
+/**
+ * @api {get} /common/diskSpace 获取磁盘空间信息
+ * @apiDescription 获取录播姬文件夹所在磁盘的空间信息
+ * @apiSuccess {number} total 总空间（GB）
+ * @apiSuccess {number} free 可用空间（GB）
+ * @apiSuccess {number} used 已用空间（GB）
+ * @apiSuccess {number} usedPercentage 使用百分比
+ */
+router$d.get("/diskSpace", async (ctx) => {
+    try {
+        const config = exports.appConfig.getAll();
+        const recoderFolder = config?.recorder?.savePath;
+        if (!recoderFolder) {
+            ctx.status = 400;
+            ctx.body = "未配置文件夹路径";
+            return;
+        }
+        if (!(await index.fs.pathExists(recoderFolder))) {
+            ctx.status = 404;
+            ctx.body = "文件夹不存在";
+            return;
+        }
+        // @ts-ignore
+        const diskInfo = await index.checkDiskSpace(recoderFolder);
+        const totalGB = diskInfo.size / (1024 * 1024 * 1024);
+        const freeGB = diskInfo.free / (1024 * 1024 * 1024);
+        const usedGB = totalGB - freeGB;
+        const usedPercentage = (usedGB / totalGB) * 100;
+        ctx.body = {
+            total: Number(totalGB.toFixed(2)),
+            free: Number(freeGB.toFixed(2)),
+            used: Number(usedGB.toFixed(2)),
+            usedPercentage: Number(usedPercentage.toFixed(2)),
+        };
+    }
+    catch (error) {
+        console.error("获取磁盘空间失败:", error);
+        ctx.status = 500;
+        ctx.body = "获取磁盘空间失败";
+    }
+});
 
 const router$c = new Router$1({
     prefix: "/user",
@@ -64464,6 +64533,8 @@ class AliyunASR {
                 model: this.model,
                 input: {
                     file_urls: [params.fileUrl],
+                    // qwen3-ASR-Flash-Filetrans 兼容
+                    file_url: params.fileUrl,
                 },
                 parameters: {
                     ...(params.vocabularyId && { vocabulary_id: params.vocabularyId }),
@@ -64474,9 +64545,10 @@ class AliyunASR {
                     }),
                     ...(params.speakerCount && { speaker_count: params.speakerCount }),
                     ...(params.languageHints && { language_hints: params.languageHints }),
+                    // qwen3-ASR-Flash-Filetran 词级时间戳
+                    enable_words: true,
                 },
             };
-            this.logger.info("提交ASR任务", { fileUrl: params.fileUrl });
             const response = await this.client.post("/api/v1/services/audio/asr/transcription", requestData, {
                 headers: {
                     "X-DashScope-Async": "enable",
@@ -64504,13 +64576,18 @@ class AliyunASR {
                     "X-DashScope-Async": "enable",
                 },
             });
+            let results = response.data.output.results || [];
+            if (!results || results.length === 0) {
+                // qwen3-ASR-Flash-Filetrans 兼容
+                results = [{ ...response.data.output.result, subtask_status: "SUCCEEDED" }];
+            }
             return {
                 taskId: response.data.output.task_id,
                 taskStatus: response.data.output.task_status,
                 submitTime: response.data.output.submit_time,
                 scheduledTime: response.data.output.scheduled_time,
                 endTime: response.data.output.end_time,
-                results: response.data.output.results,
+                results: results,
             };
         }
         catch (error) {
@@ -64682,6 +64759,454 @@ class AliyunASR {
     }
 }
 
+/**
+ * OpenAI Whisper ASR 语音识别类
+ * 使用 OpenAI Whisper API 进行录音文件识别
+ */
+class OpenAIWhisperASR {
+    client;
+    model;
+    logger;
+    /**
+     * 创建 OpenAI Whisper ASR 实例
+     */
+    constructor(options) {
+        const { apiKey, baseURL = "https://api.openai.com/v1", model = "whisper-1" } = options;
+        this.model = model;
+        this.logger = options.logger || index.logObj;
+        this.client = index.axios.create({
+            baseURL,
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            timeout: 300000, // 5分钟超时
+        });
+    }
+    /**
+     * 识别音频文件（通过文件URL）
+     * 注意：OpenAI Whisper API 不支持直接传URL，需要先下载文件
+     *
+     * @param fileUrl 音频文件URL
+     * @returns 转写结果
+     */
+    async recognize(fileUrl) {
+        this.logger.info(`开始下载文件: ${fileUrl}`);
+        // 下载文件到临时位置
+        const response = await index.axios.get(fileUrl, {
+            responseType: "arraybuffer",
+        });
+        const tempFilePath = `/tmp/whisper-temp-${Date.now()}.audio`;
+        await index.fs.writeFile(tempFilePath, response.data);
+        try {
+            const result = await this.recognizeLocalFile(tempFilePath);
+            return result;
+        }
+        finally {
+            // 清理临时文件
+            await index.fs.remove(tempFilePath).catch((err) => {
+                this.logger.warn(`清理临时文件失败: ${err.message}`);
+            });
+        }
+    }
+    /**
+     * 识别本地音频文件
+     *
+     * @param filePath 本地音频文件路径
+     * @param options 可选参数
+     * @returns 转写结果
+     */
+    async recognizeLocalFile(filePath, options) {
+        this.logger.info(`开始识别本地文件: ${filePath}`);
+        // 检查文件是否存在
+        if (!(await index.fs.pathExists(filePath))) {
+            throw new Error(`文件不存在: ${filePath}`);
+        }
+        // 创建 FormData
+        const formData = new index.FormData();
+        formData.append("file", index.fs.createReadStream(filePath));
+        formData.append("model", this.model);
+        formData.append("response_format", "verbose_json"); // 使用 verbose_json 获取时间戳
+        if (options?.prompt) {
+            formData.append("prompt", options.prompt);
+        }
+        if (options?.language) {
+            formData.append("language", options.language);
+        }
+        if (options?.temperature !== undefined) {
+            formData.append("temperature", options.temperature.toString());
+        }
+        try {
+            const response = await this.client.post("/audio/transcriptions", formData, {
+                headers: {
+                    ...formData.getHeaders(),
+                },
+            });
+            this.logger.info(`识别完成，文本长度: ${response.data.text.length}`);
+            return response.data;
+        }
+        catch (error) {
+            const errorMessage = error.response?.data?.error?.message || error.message || "未知错误";
+            this.logger.error(`OpenAI Whisper 识别失败: ${errorMessage}`);
+            throw new Error(`OpenAI Whisper 识别失败: ${errorMessage}`);
+        }
+    }
+}
+
+/**
+ * FFmpeg Whisper ASR 实现
+ * 使用 spawn 直接调用 ffmpeg 的 whisper 滤镜
+ */
+class FFmpegWhisperASR {
+    options;
+    constructor(options) {
+        this.options = {
+            logger: index.logObj,
+            language: "zh",
+            queue: 20,
+            ...options,
+        };
+        // 验证 ffmpeg 路径
+        if (!index.fs.existsSync(this.options.ffmpegPath)) {
+            throw new Error(`FFmpeg 路径不存在: ${this.options.ffmpegPath}`);
+        }
+        // 验证模型文件路径
+        if (!index.fs.existsSync(this.options.model)) {
+            throw new Error(`Whisper 模型文件不存在: ${this.options.model}`);
+        }
+    }
+    /**
+     * 识别本地音频文件
+     * @param filePath 本地文件路径
+     * @returns Whisper 转写结果
+     */
+    async recognizeLocalFile(filePath) {
+        if (!index.fs.existsSync(filePath)) {
+            throw new Error(`音频文件不存在: ${filePath}`);
+        }
+        // 创建临时目录存放结果
+        const tempDir = require$$0$7.join(require$$1$5.tmpdir(), "whisper-asr");
+        await index.fs.ensureDir(tempDir);
+        // 生成唯一的输出文件名
+        const outputFile = require$$0$7.join(tempDir, `${v4()}.json`);
+        try {
+            // 执行 ffmpeg 命令
+            await this.executeFFmpeg(filePath, outputFile);
+            // 读取结果文件
+            if (!index.fs.existsSync(outputFile)) {
+                throw new Error(`Whisper 未生成结果文件: ${outputFile}`);
+            }
+            // 读取 JSONL 文件（每行一个 JSON 对象）
+            const resultContent = await index.fs.readFile(outputFile, "utf-8");
+            const segments = resultContent
+                .split("\n")
+                .filter((line) => line.trim())
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch (error) {
+                    this.options.logger.warn(`解析 JSONL 行失败: ${line}`);
+                    return null;
+                }
+            })
+                .filter((seg) => seg !== null);
+            this.options.logger.info(`Whisper 识别完成: ${filePath}, 共 ${segments.length} 个片段`);
+            return { segments };
+        }
+        catch (error) {
+            this.options.logger.error(`Whisper 识别失败: ${error}`);
+            throw error;
+        }
+        finally {
+            console.log("清理临时文件:", outputFile);
+            // 清理临时文件
+            // if (fs.existsSync(outputFile)) {
+            //   await fs.remove(outputFile);
+            // }
+        }
+    }
+    /**
+     * 执行 ffmpeg whisper 命令
+     * @param inputFile 输入音频文件
+     * @param outputFile 输出 JSON 文件
+     */
+    async executeFFmpeg(inputFile, outputFile) {
+        return new Promise((resolve, reject) => {
+            // 构建 whisper 滤镜参数（使用 jsonl 格式）
+            const whisperFilter = `whisper=model=${index.escaped(this.options.model)}:language=${index.escaped(this.options.language)}:destination=${index.escaped(outputFile)}:format=json:queue=${this.options.queue}`;
+            // ffmpeg 命令参数
+            const args = [
+                "-i",
+                inputFile,
+                "-af",
+                whisperFilter,
+                "-f",
+                "null",
+                "-", // 输出到 null
+            ];
+            this.options.logger.info(`执行 FFmpeg Whisper 命令: ${this.options.ffmpegPath} ${args.join(" ")}`);
+            // 使用 spawn 执行命令
+            const process = require$$0$e.spawn(this.options.ffmpegPath, args);
+            let stderr = "";
+            // 收集标准错误输出（ffmpeg 的日志）
+            process.stderr.on("data", (data) => {
+                const text = data.toString();
+                stderr += text;
+                // this.options.logger.debug(`FFmpeg stderr: ${text}`);
+            });
+            // 处理进程退出
+            process.on("close", (code) => {
+                if (code === 0) {
+                    this.options.logger.info("FFmpeg Whisper 执行成功");
+                    resolve();
+                }
+                else {
+                    this.options.logger.error(`FFmpeg 执行失败，退出码: ${code}`);
+                    this.options.logger.error(`错误信息: ${stderr}`);
+                    reject(new Error(`FFmpeg 执行失败，退出码: ${code}\n${stderr}`));
+                }
+            });
+            // 处理错误
+            process.on("error", (error) => {
+                this.options.logger.error(`FFmpeg 进程错误: ${error}`);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * 识别音频 URL（不支持）
+     * 由于 ffmpeg whisper 需要本地文件，URL 需要先下载
+     */
+    async recognize(_fileUrl) {
+        throw new Error("FFmpeg Whisper 不支持直接识别 URL，请先下载音频文件后使用 recognizeLocalFile");
+    }
+}
+
+/**
+ * 获取模型参数
+ * @returns 模型参数对象
+ */
+function getModel(modelId, iConfig) {
+    if (!modelId) {
+        throw new Error("模型ID未定义");
+    }
+    let config = iConfig;
+    if (!config) {
+        config = index.appConfig.getAll();
+    }
+    const model = config.ai.models.find((m) => m.modelId === modelId);
+    if (!model) {
+        throw new Error(`找不到模型：${modelId}`);
+    }
+    return model;
+}
+
+/**
+ * 阿里云 ASR 适配器
+ */
+class AliyunASRAdapter {
+    client;
+    constructor(config) {
+        this.client = new AliyunASR({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+            model: config.model,
+            logger: index.logObj,
+        });
+    }
+    async recognize(fileUrl) {
+        const result = await this.client.recognize(fileUrl);
+        return this.transformAliyunResult(result);
+    }
+    async recognizeLocalFile(filePath) {
+        const result = await this.client.recognizeLocalFile(filePath);
+        return this.transformAliyunResult(result);
+    }
+    /**
+     * 转换阿里云格式为标准格式
+     */
+    transformAliyunResult(result) {
+        const transcript = result.transcripts?.[0];
+        if (!transcript) {
+            throw new Error("阿里云 ASR 返回结果为空");
+        }
+        const segments = [];
+        const words = [];
+        // 转换句子级别数据
+        transcript.sentences?.forEach((sentence, index) => {
+            segments.push({
+                id: index,
+                start: sentence.begin_time / 1000, // 毫秒转秒
+                end: sentence.end_time / 1000,
+                text: sentence.text,
+                speaker: sentence.speakerId?.toString(),
+            });
+            // 转换词级别数据
+            sentence.words?.forEach((word) => {
+                words.push({
+                    start: word.begin_time / 1000,
+                    end: word.end_time / 1000,
+                    word: word.text,
+                    punctuation: word.punctuation,
+                    speaker: word.speakerId?.toString(),
+                });
+            });
+        });
+        return {
+            text: transcript.text,
+            duration: result.properties.original_duration_in_milliseconds
+                ? result.properties.original_duration_in_milliseconds / 1000
+                : undefined,
+            language: undefined, // 阿里云不返回语言信息
+            segments,
+            words: words.length > 0 ? words : undefined,
+        };
+    }
+}
+/**
+ * OpenAI Whisper ASR 适配器
+ */
+class OpenAIASRAdapter {
+    client;
+    constructor(config) {
+        this.client = new OpenAIWhisperASR({
+            apiKey: config.apiKey,
+            baseURL: config.baseURL,
+            model: config.model,
+            logger: index.logObj,
+        });
+    }
+    async recognize(fileUrl) {
+        const result = await this.client.recognize(fileUrl);
+        return this.transformOpenAIResult(result);
+    }
+    async recognizeLocalFile(filePath) {
+        const result = await this.client.recognizeLocalFile(filePath);
+        return this.transformOpenAIResult(result);
+    }
+    /**
+     * 转换 OpenAI Whisper 格式为标准格式
+     */
+    transformOpenAIResult(result) {
+        const segments = result.segments.map((segment) => ({
+            id: segment.id,
+            start: segment.start,
+            end: segment.end,
+            text: segment.text.trim(),
+            speaker: undefined, // Whisper 不支持说话人分离
+        }));
+        return {
+            text: result.text,
+            duration: result.duration,
+            language: result.language,
+            segments,
+            words: undefined, // Whisper API 不返回词级别时间戳
+        };
+    }
+}
+/**
+ * FFmpeg Whisper ASR 适配器
+ */
+class FFmpegWhisperASRAdapter {
+    client;
+    constructor(config) {
+        this.client = new FFmpegWhisperASR({
+            ffmpegPath: config.ffmpegPath,
+            model: config.model,
+            language: config.language || "zh",
+            queue: config.queue || 20,
+            logger: index.logObj,
+        });
+    }
+    async recognize() {
+        throw new Error("FFmpeg Whisper 不支持直接识别 URL，请使用 recognizeLocalFile");
+    }
+    async recognizeLocalFile(filePath) {
+        const result = await this.client.recognizeLocalFile(filePath);
+        return this.transformWhisperResult(result);
+    }
+    /**
+     * 转换 FFmpeg Whisper 格式为标准格式
+     */
+    transformWhisperResult(result) {
+        if (!result.segments || result.segments.length === 0) {
+            throw new Error("Whisper 返回结果为空");
+        }
+        // 转换段落格式（毫秒转秒）
+        const segments = result.segments.map((segment, index) => ({
+            id: index,
+            start: segment.start / 1000, // 毫秒转秒
+            end: segment.end / 1000, // 毫秒转秒
+            text: segment.text,
+        }));
+        // 构建完整文本
+        const text = segments.map((s) => s.text).join("");
+        // 计算总时长
+        const duration = segments.length > 0 ? segments[segments.length - 1].end : 0;
+        return {
+            text,
+            duration,
+            language: undefined, // Whisper 在 JSONL 输出中不包含语言信息
+            segments,
+            words: undefined, // JSONL 格式不提供词级别时间戳
+        };
+    }
+}
+/**
+ * 获取供应商配置
+ */
+function getVendor$1(vendorId) {
+    const data = index.appConfig.get("ai") || {};
+    const vendor = data.vendors.find((v) => v.id === vendorId);
+    if (!vendor) {
+        throw new Error(`未找到 ID 为 ${vendorId} 的供应商配置`);
+    }
+    return vendor;
+}
+/**
+ * 创建 ASR 提供商实例
+ * @param modelId 模型 ID
+ * @returns ASR 提供商实例
+ */
+function createASRProvider(modelId) {
+    // 获取模型配置
+    const model = getModel(modelId);
+    // 获取供应商配置
+    const vendor = getVendor$1(model.vendorId);
+    // 根据 provider 类型创建对应的适配器
+    const config = {
+        apiKey: vendor.apiKey,
+        baseURL: vendor.baseURL,
+        model: model.modelName,
+    };
+    switch (vendor.provider) {
+        case "aliyun":
+            return new AliyunASRAdapter(config);
+        case "openai":
+            return new OpenAIASRAdapter(config);
+        case "ffmpeg":
+            if (!vendor.baseURL) {
+                throw new Error("FFmpeg provider 需要配置 baseURL（ffmpeg 执行文件路径）");
+            }
+            return new FFmpegWhisperASRAdapter({
+                ffmpegPath: vendor.baseURL, // baseURL 存储 ffmpeg 路径
+                model: model.modelName, // modelName 存储模型文件路径
+            });
+        default:
+            throw new Error(`不支持的 ASR 提供商: ${vendor.provider}`);
+    }
+}
+/**
+ * 识别音频文件（返回标准格式）
+ * @param file 音频文件
+ * @param modelId 模型id
+ * @returns
+ */
+function recognize$1(file, modelId) {
+    const asrProvider = createASRProvider(modelId);
+    return asrProvider.recognizeLocalFile(file);
+}
+
 const default_format = 'RFC3986';
 const formatters = {
     RFC1738: (v) => String(v).replace(/%20/g, '+'),
@@ -75823,131 +76348,18 @@ async function musicDetect(videoPath, iConfig, onProgress) {
     onProgress?.({ stage: "complete", percentage: 100, message: "分析完成" });
     return segments;
 }
-/**
- * 音乐字幕优化
- */
-function optimizeMusicSubtitles(results) {
-    // 去除"，"、“。”等标点符号
-    const transcripts = results.transcripts?.map((transcript) => {
-        const optimizedSentences = transcript.sentences?.map((sentence) => {
-            let optimizedText = sentence.text.replace(/[，。、“”‘’！？]/g, " ");
-            return {
-                ...sentence,
-                text: optimizedText,
-            };
-        });
-        return {
-            ...transcript,
-            sentences: optimizedSentences,
-        };
-    });
-    return {
-        ...results,
-        transcripts: transcripts,
-    };
-}
 function convert2Srt(detail, offset) {
-    let srt = "";
-    let index = 1;
-    for (const transcript of detail.transcripts || []) {
-        for (const sentence of transcript.sentences || []) {
-            const start = new Date(sentence.begin_time + offset)
-                .toISOString()
-                .substr(11, 12)
-                .replace(".", ",");
-            const end = new Date(sentence.end_time + offset)
-                .toISOString()
-                .substr(11, 12)
-                .replace(".", ",");
-            srt += `${index}\n${start} --> ${end}\n${sentence.text}\n\n`;
-            index++;
-        }
-    }
-    return srt;
-}
-function convert2Srt2(detail, offset) {
-    let srt = "";
-    let index = 1;
-    for (const sentence of detail || []) {
-        const start = new Date(sentence.st + offset).toISOString().substr(11, 12).replace(".", ",");
-        const end = new Date(sentence.et + offset).toISOString().substr(11, 12).replace(".", ",");
-        const text = (sentence.t || "").replace(/[，。、“”‘’！？]/g, " ");
-        srt += `${index}\n${start} --> ${end}\n${text}\n\n`;
-        index++;
-    }
-    return srt;
-}
-/**
- * 获取 AI 服务商的 API Key，现在是随便写，只支持阿里
- * @returns
- */
-function getApiKey() {
-    const data = index.appConfig.get("ai") || {};
-    if (data?.vendors.length === 0) {
-        throw new Error("请先在配置中设置 AI 服务商的 API Key");
-    }
-    return data.vendors[0].apiKey || "";
-}
-/**
- * 音频识别
- * @param file
- * @param key
- * @returns
- */
-async function asrRecognize(file, vendorId) {
-    const { apiKey } = getVendor(vendorId);
-    const asr = new AliyunASR({
-        apiKey: apiKey,
-    });
-    try {
-        const results = await asr.recognizeLocalFile(file);
-        // console.log("识别结果:", results.transcripts?.[0]);
-        // console.log("已将字幕保存到 output.srt 文件");
-        return results;
-    }
-    catch (error) {
-        index.logObj.error("ASR 识别失败:", error);
-        throw error;
-    }
-}
-/**
- * 使用通义千问 LLM 示例
- */
-async function llm(message, systemPrompt, opts = {}) {
-    console.log("=== 示例: 使用通义千问 LLM ===");
-    const apiKey = opts.key ?? getApiKey();
-    const llm = new QwenLLM({
-        apiKey: apiKey,
-        model: "qwen-plus",
-    });
-    try {
-        // const testData = fs.readFileSync(
-        //   "C:\\Users\\renmu\\Downloads\\新建文件夹 (2)\\cleaned_data.json",
-        // );
-        // console.log("读取测试数据，长度:", message + testData, testData.length);
-        const response = await llm.sendMessage(message, systemPrompt, {
-            // responseFormat: zodResponseFormat(Song, "song"),
-            enableSearch: opts.enableSearch ?? false,
-            responseFormat: opts.jsonResponse ? { type: "json_object" } : undefined,
-            // @ts-ignore
-            stream: opts.stream ?? undefined,
-            searchOptions: {
-                forcedSearch: opts.enableSearch ?? false,
-            },
-        });
-        if ("content" in response) {
-            index.logObj.info("LLM 请求成功", JSON.stringify(response));
-            // console.log("提问:", response);
-            // console.log("回复:", response.content);
-            // console.log("Token 使用:", response.usage);
-            return response;
-        }
-        throw new Error("LLM 未返回预期的响应内容");
-    }
-    catch (error) {
-        console.error("LLM 请求失败:", error);
-        throw error;
-    }
+    const srtNodes = detail
+        .filter((word) => word.t.trim() !== "")
+        .map((word) => ({
+        type: "cue",
+        data: {
+            start: word.st + offset,
+            end: word.et + offset,
+            text: word.t,
+        },
+    }));
+    return stringifySync(srtNodes, { format: "SRT" });
 }
 function getVendor(vendorId) {
     const data = index.appConfig.get("ai") || {};
@@ -75957,22 +76369,11 @@ function getVendor(vendorId) {
     }
     return vendor;
 }
-/**
- * 获取歌词优化配置
- */
-function getLyricOptimizeConfig() {
-    const { data, llmVendorId, llmModel } = getSongRecognizeConfig();
-    return {
-        vendorId: data?.songLyricOptimize?.vendorId || llmVendorId,
-        prompt: data?.songLyricOptimize?.prompt,
-        model: data?.songLyricOptimize?.model || llmModel,
-        enableStructuredOutput: data?.songLyricOptimize?.enableStructuredOutput ?? true,
-    };
-}
 /**
  * 歌词优化
  * @param lyrics - 原始歌词文本
  * @param offset - 偏移时间，单位毫秒
+ * @returns 优化后的 ASRWord 数组
  */
 async function optimizeLyrics(asrData, lyrics, offset) {
     const { vendorId, prompt, model, enableStructuredOutput } = getLyricOptimizeConfig();
@@ -75983,15 +76384,24 @@ async function optimizeLyrics(asrData, lyrics, offset) {
         baseURL: baseURL,
     });
     const asrCleanedSentences = [];
-    for (const transcript of asrData.transcripts || []) {
-        for (const sentence of transcript.sentences || []) {
-            for (const word of sentence.words || []) {
-                asrCleanedSentences.push({
-                    st: word.begin_time,
-                    et: word.end_time,
-                    t: word.text,
-                });
-            }
+    if (asrData.words && asrData.words.length !== 0) {
+        // 优先使用词级时间戳
+        for (const word of asrData.words) {
+            asrCleanedSentences.push({
+                st: word.start * 1000, // 秒转毫秒
+                et: word.end * 1000,
+                t: word.word,
+            });
+        }
+    }
+    if (asrCleanedSentences.length === 0) {
+        // 回退到分段级时间戳
+        for (const segment of asrData.segments) {
+            asrCleanedSentences.push({
+                st: segment.start * 1000, // 秒转毫秒
+                et: segment.end * 1000,
+                t: segment.text,
+            });
         }
     }
     index.logObj.info("使用 LLM 进行歌词优化...", {
@@ -76011,8 +76421,13 @@ async function optimizeLyrics(asrData, lyrics, offset) {
     try {
         const json = JSON.parse(response.content);
         const aSRWords = Array.isArray(json) ? json : json.data;
-        const srtData = convert2Srt2(aSRWords, offset);
-        return srtData;
+        // 应用偏移时间
+        const wordsWithOffset = aSRWords.map((word) => ({
+            st: word.st + offset,
+            et: word.et + offset,
+            t: word.t,
+        }));
+        return wordsWithOffset;
     }
     catch (e) {
         index.logObj.error("LLM 返回内容非 JSON 格式，尝试按纯文本处理", e);
@@ -76023,30 +76438,48 @@ async function optimizeLyrics(asrData, lyrics, offset) {
  * 获取歌曲识别配置
  */
 function getSongRecognizeConfig() {
-    const data = index.appConfig.get("ai") || {};
-    if (data?.vendors.length === 0) {
-        throw new Error("请先在配置中设置 AI 服务商的 API Key");
-    }
-    const asrVendorId = data.vendors.find((v) => v.provider === "aliyun")?.id;
-    if (!asrVendorId) {
-        throw new Error("请先在配置中设置 阿里云 ASR 服务商的 API Key");
+    const config = index.appConfig.getAll();
+    const data = config.ai;
+    const asrModelId = data.songRecognizeAsr?.modelId;
+    if (!asrModelId) {
+        throw new Error("请先在配置中设置歌曲识别 ASR 模型");
     }
-    let llmVendorId = asrVendorId;
-    if (data?.songRecognizeLlm?.vendorId) {
-        llmVendorId = data.songRecognizeLlm.vendorId;
+    const llmModel = getModel(data?.songRecognizeLlm?.modelId, config);
+    const llmVendor = data.vendors.find((v) => v.id === llmModel.vendorId);
+    if (!llmVendor) {
+        throw new Error("找不到LLM模型关联的供应商");
     }
     return {
         data,
-        asrVendorId,
-        llmVendorId,
+        asrModelId,
+        llmVendorId: llmVendor.id,
+        llmModel: llmModel.modelName,
         llmPrompt: data?.songRecognizeLlm?.prompt,
-        llmModel: data?.songRecognizeLlm?.model || "qwen-plus",
         enableSearch: data?.songRecognizeLlm?.enableSearch ?? false,
         maxInputLength: data?.songRecognizeLlm?.maxInputLength || 300,
         enableStructuredOutput: data?.songRecognizeLlm?.enableStructuredOutput ?? true,
         lyricOptimize: data?.songRecognizeLlm?.lyricOptimize ?? true,
     };
 }
+/**
+ * 获取歌词优化配置
+ */
+function getLyricOptimizeConfig() {
+    const config = index.appConfig.getAll();
+    const data = config.ai;
+    let modelId = data?.songLyricOptimize?.modelId;
+    const model = getModel(modelId);
+    const vendor = data.vendors.find((v) => v.id === model.vendorId);
+    if (!vendor) {
+        throw new Error("找不到LLM模型关联的供应商");
+    }
+    return {
+        vendorId: vendor.id,
+        prompt: data?.songLyricOptimize?.prompt,
+        model: model.modelName,
+        enableStructuredOutput: data?.songLyricOptimize?.enableStructuredOutput ?? true,
+    };
+}
 /**
  * 使用 LLM 识别歌曲名称
  * @param asrText - ASR 识别的文本内容
@@ -76100,7 +76533,7 @@ async function recognizeSongNameWithLLM(asrText, vendorId, options) {
  * @param audioStartTime - 音频开始时间（秒）
  */
 async function songRecognize(file, audioStartTime = 0) {
-    const { asrVendorId, llmVendorId, llmPrompt, llmModel, enableSearch, maxInputLength, enableStructuredOutput, lyricOptimize, } = getSongRecognizeConfig();
+    const { asrModelId, llmVendorId, llmPrompt, llmModel, enableSearch, maxInputLength, enableStructuredOutput, lyricOptimize, } = getSongRecognizeConfig();
     let info = await recognize(file, lyricOptimize);
     if (!info) {
         index.logObj.warn("Shazam 未识别到任何歌曲信息");
@@ -76114,8 +76547,8 @@ async function songRecognize(file, audioStartTime = 0) {
         };
     }
     // 如果开启了歌词优化，首先要asr识别
-    const data = await asrRecognize(file, asrVendorId);
-    const messages = data.transcripts?.[0]?.text || "";
+    const data = await recognize$1(file, asrModelId);
+    const messages = data.text || "";
     if (!messages) {
         index.logObj.warn("没有识别到任何文本内容，无法进行歌曲识别");
         return;
@@ -76135,15 +76568,30 @@ async function songRecognize(file, audioStartTime = 0) {
         return;
     }
     const rawLyrics = info?.lyrics;
-    let srtData = "";
-    if (rawLyrics) {
-        if (lyricOptimize) {
-            srtData = await optimizeLyrics(data, rawLyrics, audioStartTime * 1000);
+    let words = [];
+    if (rawLyrics && lyricOptimize) {
+        try {
+            words = await optimizeLyrics(data, rawLyrics, audioStartTime * 1000);
         }
-        else {
-            srtData = convert2Srt(optimizeMusicSubtitles(data), audioStartTime * 1000);
+        catch (error) {
+            index.logObj.error("歌词优化失败:", error);
         }
     }
+    if (words.length === 0) {
+        // 如果没有歌词优化结果，使用原始 ASR 结果
+        const segments = data.segments || [];
+        // 使用词级时间戳生成 ASRWord 数组
+        words = segments.map((sentence) => {
+            let text = sentence.text.replace(/[，。、“”‘’！？]/g, " ");
+            return {
+                st: sentence.start * 1000 + audioStartTime * 1000,
+                et: sentence.end * 1000 + audioStartTime * 1000,
+                t: text,
+            };
+        });
+    }
+    // 统一生成 SRT
+    const srtData = convert2Srt(words, 0);
     const name = info?.name;
     return {
         name: name,
@@ -76621,7 +77069,7 @@ router$8.post("/formatTitle", async (ctx) => {
 router$8.post("/formatPartTitle", async (ctx) => {
     const data = ctx.request.body;
     const template = (data.template || "");
-    const title = formatPartTitle({
+    const title = formatPartTitle(data.options ?? {
         title: "标题",
         username: "主播名",
         time: new Date().toISOString(),
@@ -78315,24 +78763,197 @@ router$2.post("/sync", async (ctx) => {
     ctx.body = task.taskId;
 });
 
+/**
+ * 根据标准 ASR 结果生成优化的 SRT 字幕
+ * @param result - 标准 ASR 识别结果
+ * @param options - 配置选项
+ * @returns SRT 格式的字幕字符串
+ */
+function convertStandardResultToSrt(result, options) {
+    const offset = options?.offset ?? 0;
+    const maxLength = options?.maxLength ?? 20;
+    const fillGap = options?.fillGap ?? 500;
+    // 如果有词级别数据，使用词级别生成（更精确）
+    if (result.words && result.words.length > 0) {
+        return convertWordsToSrt(result.words, { offset, maxLength, fillGap });
+    }
+    // 否则直接使用分段数据，不做分割和补全
+    const srtNodes = result.segments
+        .filter((segment) => segment.text.trim())
+        .map((segment) => ({
+        type: "cue",
+        data: {
+            start: segment.start * 1000 + offset, // 转换为毫秒
+            end: segment.end * 1000 + offset,
+            text: segment.text.trim(),
+        },
+    }));
+    return stringifySync(srtNodes, { format: "SRT" });
+}
+/**
+ * 根据词级别数据生成 SRT 字幕
+ */
+function convertWordsToSrt(words, options) {
+    const { offset, maxLength, fillGap } = options;
+    const subtitles = [];
+    let accumulatedText = "";
+    let startTime = 0;
+    let endTime = 0;
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        if (accumulatedText === "") {
+            startTime = word.start;
+        }
+        // 累积词文本
+        accumulatedText += word.word;
+        endTime = word.end;
+        // 检查是否需要断句
+        let shouldBreak = false;
+        // 1. 如果有标点符号且字符数大于4，断句
+        if (word.punctuation && accumulatedText.length > 4) {
+            accumulatedText += word.punctuation;
+            shouldBreak = true;
+        }
+        // 如果有标点但字符数不够，只添加标点继续累积
+        else if (word.punctuation) {
+            accumulatedText += word.punctuation;
+        }
+        // 2. 长度超过最大限制，强制断句
+        else if (accumulatedText.length >= maxLength) {
+            shouldBreak = true;
+        }
+        if (shouldBreak) {
+            const cleanedText = accumulatedText.replace(/[\p{P}\p{S}]+$/u, "").trim();
+            if (cleanedText) {
+                subtitles.push({
+                    start: startTime * 1000 + offset, // 转换为毫秒
+                    end: endTime * 1000 + offset,
+                    text: cleanedText,
+                });
+            }
+            accumulatedText = "";
+            startTime = 0;
+            endTime = 0;
+        }
+    }
+    // 处理剩余文本
+    if (accumulatedText.trim()) {
+        const cleanedText = accumulatedText.replace(/[\p{P}\p{S}]+$/u, "").trim();
+        if (cleanedText) {
+            subtitles.push({
+                start: startTime * 1000 + offset,
+                end: endTime * 1000 + offset,
+                text: cleanedText,
+            });
+        }
+    }
+    // 补齐字幕间隔
+    if (fillGap > 0) {
+        for (let i = 0; i < subtitles.length - 1; i++) {
+            const current = subtitles[i];
+            const next = subtitles[i + 1];
+            const gap = next.start - current.end;
+            if (gap > 0 && gap <= fillGap) {
+                current.end += gap * 0.6;
+                next.start -= gap * 0.4;
+            }
+        }
+    }
+    // 生成 SRT
+    const srtNodes = subtitles.map((sub) => ({
+        type: "cue",
+        data: {
+            start: sub.start,
+            end: sub.end,
+            text: sub.text,
+        },
+    }));
+    return stringifySync(srtNodes, { format: "SRT" });
+}
+/**
+ * 字幕识别 - 将音频/视频文件转换为 SRT 字幕
+ * @param file - 音频或视频文件路径
+ * @param vendorId - AI 服务商 ID
+ * @param options - 配置选项
+ * @returns SRT 格式的字幕字符串
+ */
+async function subtitleRecognize(file, modelId, options) {
+    const offset = (options?.offset ?? 0) * 1000; // 转换为毫秒
+    const maxLength = options?.maxLength ?? 26;
+    const timeGapThreshold = options?.timeGapThreshold ?? 300;
+    const fillGap = options?.fillGap ?? 1000;
+    const disableCache = options?.disableCache;
+    index.logObj.info("开始字幕识别", {
+        file,
+        offset,
+        maxLength,
+        timeGapThreshold,
+        fillGap,
+        disableCache,
+    });
+    try {
+        // 生成缓存路径
+        const cachePath = index.getTempPath();
+        const fileHash = await index.calculateFileQuickHash(file);
+        // TODO:缓存有bug，第一个是多模型切换、第二个是不同参数热词参数不同
+        const cacheFileName = `asr_subtitle_cache_${fileHash}_${modelId}.json`;
+        const cacheFilePath = path$7.join(cachePath, cacheFileName);
+        let asrResult = null;
+        // 尝试从缓存读取
+        if (!disableCache && (await index.fs.pathExists(cacheFilePath))) ;
+        if (!asrResult) {
+            // 调用 ASR 识别（使用新的统一接口）
+            asrResult = await recognize$1(file, modelId);
+            // 保存到缓存（如果未禁用缓存）
+            if (!disableCache) ;
+        }
+        if (!asrResult.segments || asrResult.segments.length === 0) {
+            index.logObj.warn("ASR 未识别到任何内容");
+            return "";
+        }
+        // 使用新的标准格式转换函数
+        const srt = convertStandardResultToSrt(asrResult, {
+            offset,
+            maxLength,
+            fillGap,
+        });
+        index.logObj.info("字幕识别完成", { subtitleCount: srt.split("\n\n").length - 1 });
+        return srt;
+    }
+    catch (error) {
+        index.logObj.error("字幕识别失败:", error);
+        throw error;
+    }
+}
+
 const router$1 = new Router$1({
     prefix: "/ai",
 });
-router$1.post("/asr", async (ctx) => {
-    const data = ctx.request.body;
-    const result = await asrRecognize(data.file, data.vendorId);
-    ctx.body = result;
-});
-router$1.post("/llm", async (ctx) => {
-    const data = ctx.request.body;
-    const result = await llm(data.message, data.systemPrompt, {
-        enableSearch: data.enableSearch,
-        key: undefined,
-        jsonResponse: data.jsonResponse,
-        stream: data.stream,
-    });
-    ctx.body = result;
-});
+// router.post("/asr", async (ctx) => {
+//   const data = ctx.request.body as {
+//     file: string;
+//     vendorId: string;
+//     model: string;
+//   };
+//   const result = await asrRecognize(data.file, { vendorId: data.vendorId, model: data.model });
+//   ctx.body = result;
+// });
+// router.post("/llm", async (ctx) => {
+//   const data = ctx.request.body as {
+//     message: string;
+//     systemPrompt?: string;
+//     enableSearch?: boolean;
+//     jsonResponse?: boolean;
+//     stream?: boolean;
+//   };
+//   const result = await llm(data.message, data.systemPrompt, {
+//     enableSearch: data.enableSearch,
+//     key: undefined,
+//     jsonResponse: data.jsonResponse,
+//     stream: data.stream,
+//   });
+//   ctx.body = result;
+// });
 router$1.post("/song_recognize", async (ctx) => {
     const data = ctx.request.body;
     if (!data.file || data.startTime == null || data.endTime == null) {
@@ -78367,6 +78988,66 @@ router$1.post("/song_recognize", async (ctx) => {
     index.fs.remove(outputFile);
     ctx.body = result;
 });
+router$1.post("/subtitle", async (ctx) => {
+    const data = ctx.request.body;
+    if (!data.file) {
+        ctx.status = 400;
+        ctx.body = {
+            error: "参数错误，必须包含 file 字段",
+        };
+        return;
+    }
+    const config = index.appConfig.get("ai") || {};
+    const asrModelId = config.subtitleRecognize.modelId;
+    if (!asrModelId) {
+        throw new Error("请先在配置中设置字幕识别ASR模型");
+    }
+    try {
+        let audioFile = data.file;
+        let needCleanup = false;
+        // 如果指定了时间范围，需要先提取音频片段
+        if (data.startTime != null && data.endTime != null) {
+            const cachePath = index.getTempPath();
+            const fileName = `${index.uuid()}.mp3`;
+            const task = await index.addExtractAudioTask(data.file, fileName, {
+                startTime: data.startTime,
+                endTime: data.endTime,
+                saveType: 2,
+                savePath: cachePath,
+                autoRun: true,
+                addQueue: false,
+                format: "libmp3lame",
+                audioBitrate: "192k",
+            });
+            audioFile = await new Promise((resolve, reject) => {
+                task.on("task-end", () => {
+                    resolve(task.output);
+                });
+                task.on("task-error", (err) => {
+                    reject(err);
+                });
+            });
+            needCleanup = true;
+        }
+        const srt = await subtitleRecognize(audioFile, asrModelId, {
+            offset: data.offset,
+            disableCache: true,
+        });
+        // 清理临时音频文件
+        if (needCleanup) {
+            index.fs.remove(audioFile);
+        }
+        ctx.body = {
+            srt,
+        };
+    }
+    catch (error) {
+        ctx.status = 500;
+        ctx.body = {
+            error: error.message || "字幕识别失败",
+        };
+    }
+});
 
 /**
  * 文件引用计数管理器
@@ -79593,8 +80274,8 @@ class WebhookHandler {
         // 5. 处理弹幕和视频压制
         const processingResult = await this.processMediaFiles(context, options, config, xmlFilePath);
         index.logObj.debug("processingResult", processingResult, options.filePath, context.part.filePath);
-        this.collectTasks(context.part.filePath, "handledVideo", config);
         if (processingResult.conversionSuccessful) {
+            this.collectTasks(context.part.filePath, "handledVideo", config);
             this.fileRefManager.releaseRef(options.filePath);
         }
         if (xmlFilePath && processingResult.danmuConversionSuccessful) {
@@ -80292,7 +80973,7 @@ class WebhookHandler {
         await this.addEditMediaTask(config.uid, aid, filePaths.map((item) => ({
             path: item.path,
             title: item.title,
-        })), limitedUploadTime, type === "raw" ? "none" : config.afterUploadDeletAction);
+        })), limitedUploadTime, config.afterUploadDeletAction);
         live.batchUpdateUploadStatus(filePaths.map((item) => item.part), "uploaded", type);
     }
     /**
@@ -80308,7 +80989,7 @@ class WebhookHandler {
         const aid = (await this.addUploadTask(config.uid, filePaths.map((item) => ({
             path: item.path,
             title: item.title,
-        })), uploadPreset, limitedUploadTime, type === "raw" ? "none" : config.afterUploadDeletAction));
+        })), uploadPreset, limitedUploadTime, config.afterUploadDeletAction));
         live[aidField] = Number(aid);
         live.batchUpdateUploadStatus(filePaths.map((item) => item.part), "uploaded", type);
     }
@@ -80413,7 +81094,7 @@ exports.handler = void 0;
 exports.appConfig = void 0;
 exports.container = void 0;
 const fileCache = createFileCache();
-path$7.dirname(require$$0$4.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-CWr6rOqY.cjs', document.baseURI).href))));
+path$7.dirname(require$$0$4.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index-DTf_Oo8U.cjs', document.baseURI).href))));
 const authMiddleware = (passKey) => {
     return async (ctx, next) => {
         const authHeader = ctx.headers["authorization"] || ctx.request.query.auth;