feat: ffmpeg download auto

manifest.json

@@ -4,7 +4,7 @@
   "name": "NapCatQQ",
   "slug": "NapCat.Framework",
   "description": "高性能的 OneBot 11 协议实现",
-  "version": "4.7.23",
+  "version": "4.7.25",
   "icon": "./logo.png",
   "authors": [
     {

package.json

@@ -2,7 +2,7 @@
   "name": "napcat",
   "private": true,
   "type": "module",
-  "version": "4.7.23",
+  "version": "4.7.25",
   "scripts": {
     "build:universal": "npm run build:webui && vite build --mode universal || exit 1",
     "build:framework": "npm run build:webui && vite build --mode framework || exit 1",
@@ -21,7 +21,6 @@
     "@eslint/compat": "^1.2.2",
     "@eslint/eslintrc": "^3.1.0",
     "@eslint/js": "^9.14.0",
-    "@ffmpeg.wasm/main": "^0.13.1",
     "@homebridge/node-pty-prebuilt-multiarch": "^0.12.0-beta.5",
     "@log4js-node/log4js-api": "^1.0.2",
     "@napneko/nap-proto-core": "^0.0.4",
@@ -63,7 +62,6 @@
     "zod": "^3.24.2"
   },
   "dependencies": {
-    "@ffmpeg.wasm/core-mt": "^0.13.2",
     "express": "^5.0.0",
     "silk-wasm": "^3.6.1",
     "ws": "^8.18.0"

src/common/download-ffmpeg.ts

@@ -0,0 +1,308 @@
+// 更正导入语句
+import * as fs from 'fs';
+import * as path from 'path';
+import * as https from 'https';
+import * as os from 'os';
+import * as compressing from 'compressing';  // 修正导入方式
+import { pipeline } from 'stream/promises';
+import { fileURLToPath } from 'url';
+import { LogWrapper } from './log';
+
+const downloadOri = "https://github.com/BtbN/FFmpeg-Builds/releases/download/autobuild-2025-04-16-12-54/ffmpeg-n7.1.1-6-g48c0f071d4-win64-lgpl-7.1.zip"
+const urls = [
+    "https://github.moeyy.xyz/" + downloadOri,
+    "https://ghp.ci/" + downloadOri,
+    "https://gh.api.99988866.xyz/" + downloadOri,
+    downloadOri
+];
+
+/**
+ * 测试URL是否可用
+ * @param url 待测试的URL
+ * @returns 如果URL可访问返回true，否则返回false
+ */
+async function testUrl(url: string): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+        const req = https.get(url, { timeout: 5000 }, (res) => {
+            // 检查状态码是否表示成功
+            const statusCode = res.statusCode || 0;
+            if (statusCode >= 200 && statusCode < 300) {
+                // 终止请求并返回true
+                req.destroy();
+                resolve(true);
+            } else {
+                req.destroy();
+                resolve(false);
+            }
+        });
+
+        req.on('error', () => {
+            resolve(false);
+        });
+
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+
+/**
+ * 查找第一个可用的URL
+ * @returns 返回第一个可用的URL，如果都不可用则返回null
+ */
+async function findAvailableUrl(): Promise<string | null> {
+    for (const url of urls) {
+        try {
+            const available = await testUrl(url);
+            if (available) {
+                return url;
+            }
+        } catch (error) {
+            // 忽略错误
+        }
+    }
+
+    return null;
+}
+/**
+ * 下载文件
+ * @param url 下载URL
+ * @param destPath 目标保存路径
+ * @returns 成功返回true，失败返回false
+ */
+async function downloadFile(url: string, destPath: string, progressCallback?: (percent: number) => void): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+        const file = fs.createWriteStream(destPath);
+
+        const req = https.get(url, (res) => {
+            const statusCode = res.statusCode || 0;
+
+            if (statusCode >= 200 && statusCode < 300) {
+                // 获取文件总大小
+                const totalSize = parseInt(res.headers['content-length'] || '0', 10);
+                let downloadedSize = 0;
+                let lastReportedPercent = -1; // 上次报告的百分比
+                let lastReportTime = 0; // 上次报告的时间戳
+
+                // 如果有内容长度和进度回调，则添加数据监听
+                if (totalSize > 0 && progressCallback) {
+                    // 初始报告 0%
+                    progressCallback(0);
+                    lastReportTime = Date.now();
+
+                    res.on('data', (chunk) => {
+                        downloadedSize += chunk.length;
+                        const currentPercent = Math.floor((downloadedSize / totalSize) * 100);
+                        const now = Date.now();
+
+                        // 只在以下条件触发回调：
+                        // 1. 百分比变化至少为1%
+                        // 2. 距离上次报告至少500毫秒
+                        // 3. 确保报告100%完成
+                        if ((currentPercent !== lastReportedPercent &&
+                            (currentPercent - lastReportedPercent >= 1 || currentPercent === 100)) &&
+                            (now - lastReportTime >= 1000 || currentPercent === 100)) {
+
+                            progressCallback(currentPercent);
+                            lastReportedPercent = currentPercent;
+                            lastReportTime = now;
+                        }
+                    });
+                }
+
+                pipeline(res, file)
+                    .then(() => {
+                        // 确保最后报告100%
+                        if (progressCallback && lastReportedPercent !== 100) {
+                            progressCallback(100);
+                        }
+                        resolve(true);
+                    })
+                    .catch(() => resolve(false));
+            } else {
+                file.close();
+                fs.unlink(destPath, () => { });
+                resolve(false);
+            }
+        });
+
+        req.on('error', () => {
+            file.close();
+            fs.unlink(destPath, () => { });
+            resolve(false);
+        });
+    });
+}
+
+/**
+ * 解压缩zip文件中的特定内容
+ * 只解压bin目录中的文件到目标目录
+ * @param zipPath 压缩文件路径
+ * @param extractDir 解压目标路径
+ */
+async function extractBinDirectory(zipPath: string, extractDir: string): Promise<void> {
+    try {
+        // 确保目标目录存在
+        if (!fs.existsSync(extractDir)) {
+            fs.mkdirSync(extractDir, { recursive: true });
+        }
+
+        // 解压文件
+        const zipStream = new compressing.zip.UncompressStream({ source: zipPath });
+
+        return new Promise<void>((resolve, reject) => {
+            // 监听条目事件
+            zipStream.on('entry', (header, stream, next) => {
+                // 获取文件路径
+                const filePath = header.name;
+
+                // 匹配内层bin目录中的文件
+                // 例如：ffmpeg-n7.1.1-6-g48c0f071d4-win64-lgpl-7.1/bin/ffmpeg.exe
+                if (filePath.includes('/bin/') && filePath.endsWith('.exe')) {
+                    // 提取文件名
+                    const fileName = path.basename(filePath);
+                    const targetPath = path.join(extractDir, fileName);
+
+                    // 创建写入流
+                    const writeStream = fs.createWriteStream(targetPath);
+
+                    // 将流管道连接到文件
+                    stream.pipe(writeStream);
+
+                    // 监听写入完成事件
+                    writeStream.on('finish', () => {
+                        next();
+                    });
+
+                    writeStream.on('error', () => {
+                        next();
+                    });
+                } else {
+                    // 跳过不需要的文件
+                    stream.resume();
+                    next();
+                }
+            });
+
+            zipStream.on('error', (err) => {
+                reject(err);
+            });
+
+            zipStream.on('finish', () => {
+                resolve();
+            });
+        });
+    } catch (err) {
+        throw err;
+    }
+}
+
+/**
+ * 下载并设置FFmpeg
+ * @param destDir 目标安装目录，默认为用户临时目录下的ffmpeg文件夹
+ * @param tempDir 临时文件目录，默认为系统临时目录
+ * @returns 返回ffmpeg可执行文件的路径，如果失败则返回null
+ */
+export async function downloadFFmpeg(
+    destDir?: string,
+    tempDir?: string,
+    progressCallback?: (percent: number, stage: string) => void
+): Promise<string | null> {
+    // 仅限Windows
+    if (os.platform() !== 'win32') {
+        return null;
+    }
+
+    const destinationDir = destDir || path.join(os.tmpdir(), 'ffmpeg');
+    const tempDirectory = tempDir || os.tmpdir();
+    const zipFilePath = path.join(tempDirectory, 'ffmpeg.zip'); // 临时下载到指定临时目录
+    const ffmpegExePath = path.join(destinationDir, 'ffmpeg.exe');
+
+    // 确保目录存在
+    if (!fs.existsSync(destinationDir)) {
+        fs.mkdirSync(destinationDir, { recursive: true });
+    }
+
+    // 确保临时目录存在
+    if (!fs.existsSync(tempDirectory)) {
+        fs.mkdirSync(tempDirectory, { recursive: true });
+    }
+
+    // 如果ffmpeg已经存在，直接返回路径
+    if (fs.existsSync(ffmpegExePath)) {
+        if (progressCallback) progressCallback(100, '已找到FFmpeg');
+        return ffmpegExePath;
+    }
+
+    // 查找可用URL
+    if (progressCallback) progressCallback(0, '查找可用下载源');
+    const availableUrl = await findAvailableUrl();
+    if (!availableUrl) {
+        return null;
+    }
+
+    // 下载文件
+    if (progressCallback) progressCallback(5, '开始下载FFmpeg');
+    const downloaded = await downloadFile(
+        availableUrl,
+        zipFilePath,
+        (percent) => {
+            // 下载占总进度的70%
+            if (progressCallback) progressCallback(5 + Math.floor(percent * 0.7), '下载FFmpeg');
+        }
+    );
+
+    if (!downloaded) {
+        return null;
+    }
+
+    try {
+        // 直接解压bin目录文件到目标目录
+        if (progressCallback) progressCallback(75, '解压FFmpeg');
+        await extractBinDirectory(zipFilePath, destinationDir);
+
+        // 清理下载文件
+        if (progressCallback) progressCallback(95, '清理临时文件');
+        try {
+            fs.unlinkSync(zipFilePath);
+        } catch (err) {
+            // 忽略清理临时文件失败的错误
+        }
+
+        // 检查ffmpeg.exe是否成功解压
+        if (fs.existsSync(ffmpegExePath)) {
+            if (progressCallback) progressCallback(100, 'FFmpeg安装完成');
+            return ffmpegExePath;
+        } else {
+            return null;
+        }
+    } catch (err) {
+        return null;
+    }
+}
+export async function downloadFFmpegIfNotExists(log:LogWrapper) {
+    // 仅限Windows
+    if (os.platform() !== 'win32') {
+        return {
+            path: null,
+            isExist: false
+        };
+    }
+    const currentPath = path.dirname(fileURLToPath(import.meta.url));
+    const ffmpeg_exist = fs.existsSync(path.join(currentPath, 'ffmpeg', 'ffmpeg.exe'));
+    const ffprobe_exist = fs.existsSync(path.join(currentPath, 'ffmpeg', 'ffprobe.exe'));
+    if (!ffmpeg_exist || !ffprobe_exist) {
+        await downloadFFmpeg('./ffmpeg', './cache', (percentage: number, message: string) => {
+            log.log(`[Ffmpeg] [Download] ${percentage}% - ${message}`);
+        });
+        return {
+            path: path.join(currentPath, 'ffmpeg'),
+            isExist: false
+        }
+    }
+    return {
+        path: path.join(currentPath, 'ffmpeg'),
+        isExist: true
+    }
+}

src/common/ffmpeg-worker.ts

@@ -1,308 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { FFmpeg } from '@ffmpeg.wasm/main';
-import { randomUUID } from 'crypto';
-import { readFileSync, statSync, writeFileSync } from 'fs';
-import type { VideoInfo } from './video';
-import { fileTypeFromFile } from 'file-type';
-import imageSize from 'image-size';
-import { parentPort } from 'worker_threads';
-export function recvTask<T>(cb: (taskData: T) => Promise<unknown>) {
-    parentPort?.on('message', async (taskData: T) => {
-        try {
-            let ret = await cb(taskData);
-            parentPort?.postMessage(ret);
-        } catch (error: unknown) {
-            parentPort?.postMessage({ error: (error as Error).message });
-        }
-    });
-}
-export function sendLog(_log: string) {
-    //parentPort?.postMessage({ log });
-}
-class FFmpegService {
-    public static async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
-        const ffmpegInstance = await FFmpeg.create({ core: '@ffmpeg.wasm/core-mt' });
-        const videoFileName = `${randomUUID()}.mp4`;
-        const outputFileName = `${randomUUID()}.jpg`;
-        try {
-            ffmpegInstance.fs.writeFile(videoFileName, readFileSync(videoPath));
-            const code = await ffmpegInstance.run('-i', videoFileName, '-ss', '00:00:01.000', '-vframes', '1', outputFileName);
-            if (code !== 0) {
-                throw new Error('Error extracting thumbnail: FFmpeg process exited with code ' + code);
-            }
-            const thumbnail = ffmpegInstance.fs.readFile(outputFileName);
-            writeFileSync(thumbnailPath, thumbnail);
-        } catch (error) {
-            console.error('Error extracting thumbnail:', error);
-            throw error;
-        } finally {
-            try {
-                ffmpegInstance.fs.unlink(outputFileName);
-            } catch (unlinkError) {
-                console.error('Error unlinking output file:', unlinkError);
-            }
-            try {
-                ffmpegInstance.fs.unlink(videoFileName);
-            } catch (unlinkError) {
-                console.error('Error unlinking video file:', unlinkError);
-            }
-        }
-    }
-
-    public static async convertFile(inputFile: string, outputFile: string, format: string): Promise<void> {
-        const ffmpegInstance = await FFmpeg.create({ core: '@ffmpeg.wasm/core-mt' });
-        const inputFileName = `${randomUUID()}.pcm`;
-        const outputFileName = `${randomUUID()}.${format}`;
-        try {
-            ffmpegInstance.fs.writeFile(inputFileName, readFileSync(inputFile));
-            const params = format === 'amr'
-                ? ['-f', 's16le', '-ar', '24000', '-ac', '1', '-i', inputFileName, '-ar', '8000', '-b:a', '12.2k', outputFileName]
-                : ['-f', 's16le', '-ar', '24000', '-ac', '1', '-i', inputFileName, outputFileName];
-            const code = await ffmpegInstance.run(...params);
-            if (code !== 0) {
-                throw new Error('Error extracting thumbnail: FFmpeg process exited with code ' + code);
-            }
-            const outputData = ffmpegInstance.fs.readFile(outputFileName);
-            writeFileSync(outputFile, outputData);
-        } catch (error) {
-            console.error('Error converting file:', error);
-            throw error;
-        } finally {
-            try {
-                ffmpegInstance.fs.unlink(outputFileName);
-            } catch (unlinkError) {
-                console.error('Error unlinking output file:', unlinkError);
-            }
-            try {
-                ffmpegInstance.fs.unlink(inputFileName);
-            } catch (unlinkError) {
-                console.error('Error unlinking input file:', unlinkError);
-            }
-        }
-    }
-
-    public static async convert(filePath: string, pcmPath: string): Promise<Buffer> {
-        const ffmpegInstance = await FFmpeg.create({ core: '@ffmpeg.wasm/core-mt' });
-        const inputFileName = `${randomUUID()}.input`;
-        const outputFileName = `${randomUUID()}.pcm`;
-        try {
-            ffmpegInstance.fs.writeFile(inputFileName, readFileSync(filePath));
-            const params = ['-y', '-i', inputFileName, '-ar', '24000', '-ac', '1', '-f', 's16le', outputFileName];
-            const code = await ffmpegInstance.run(...params);
-            if (code !== 0) {
-                throw new Error('FFmpeg process exited with code ' + code);
-            }
-            const outputData = ffmpegInstance.fs.readFile(outputFileName);
-            writeFileSync(pcmPath, outputData);
-            return Buffer.from(outputData);
-        } catch (error: any) {
-            throw new Error('FFmpeg处理转换出错: ' + error.message);
-        } finally {
-            try {
-                ffmpegInstance.fs.unlink(outputFileName);
-            } catch (unlinkError) {
-                console.error('Error unlinking output file:', unlinkError);
-            }
-            try {
-                ffmpegInstance.fs.unlink(inputFileName);
-            } catch (unlinkError) {
-                console.error('Error unlinking output file:', unlinkError);
-            }
-        }
-    }
-    public static async getVideoInfo(videoPath: string, thumbnailPath: string): Promise<VideoInfo> {
-        const startTime = Date.now();
-        sendLog(`开始获取视频信息: ${videoPath}`);
-
-        // 创建一个超时包装函数
-        const withTimeout = <T>(promise: Promise<T>, timeoutMs: number, taskName: string): Promise<T> => {
-            return Promise.race([
-                promise,
-                new Promise<T>((_, reject) => {
-                    setTimeout(() => reject(new Error(`任务超时: ${taskName} (${timeoutMs}ms)`)), timeoutMs);
-                })
-            ]);
-        };
-
-        // 并行执行多个任务
-        const [fileInfo, durationInfo] = await Promise.all([
-            // 任务1: 获取文件信息和提取缩略图
-            (async () => {
-                sendLog('开始任务1: 获取文件信息和提取缩略图');
-
-                // 获取文件信息 (并行)
-                const fileInfoStartTime = Date.now();
-                const [fileType, fileSize] = await Promise.all([
-                    withTimeout(fileTypeFromFile(videoPath), 10000, '获取文件类型')
-                        .then(result => {
-                            sendLog(`获取文件类型完成，耗时: ${Date.now() - fileInfoStartTime}ms`);
-                            return result;
-                        }),
-                    (async () => {
-                        const result = statSync(videoPath).size;
-                        sendLog(`获取文件大小完成，耗时: ${Date.now() - fileInfoStartTime}ms`);
-                        return result;
-                    })()
-                ]);
-
-                // 直接实现缩略图提取 (不调用extractThumbnail方法)
-                const thumbStartTime = Date.now();
-                sendLog('开始提取缩略图');
-
-                const ffmpegInstance = await withTimeout(
-                    FFmpeg.create({ core: '@ffmpeg.wasm/core-mt' }),
-                    15000,
-                    '创建FFmpeg实例(缩略图)'
-                );
-
-                const videoFileName = `${randomUUID()}.mp4`;
-                const outputFileName = `${randomUUID()}.jpg`;
-
-                try {
-                    // 写入视频文件到FFmpeg
-                    const writeFileStartTime = Date.now();
-                    ffmpegInstance.fs.writeFile(videoFileName, readFileSync(videoPath));
-                    sendLog(`写入视频文件到FFmpeg完成，耗时: ${Date.now() - writeFileStartTime}ms`);
-
-                    // 提取缩略图
-                    const extractStartTime = Date.now();
-                    const code = await withTimeout(
-                        ffmpegInstance.run('-i', videoFileName, '-ss', '00:00:01.000', '-vframes', '1', outputFileName),
-                        30000,
-                        '提取缩略图'
-                    );
-                    sendLog(`FFmpeg提取缩略图命令执行完成，耗时: ${Date.now() - extractStartTime}ms`);
-
-                    if (code !== 0) {
-                        throw new Error('Error extracting thumbnail: FFmpeg process exited with code ' + code);
-                    }
-
-                    // 读取并保存缩略图
-                    const saveStartTime = Date.now();
-                    const thumbnail = ffmpegInstance.fs.readFile(outputFileName);
-                    writeFileSync(thumbnailPath, thumbnail);
-                    sendLog(`读取并保存缩略图完成，耗时: ${Date.now() - saveStartTime}ms`);
-
-                    // 获取缩略图尺寸
-                    const imageSizeStartTime = Date.now();
-                    const image = imageSize(thumbnailPath);
-                    sendLog(`获取缩略图尺寸完成，耗时: ${Date.now() - imageSizeStartTime}ms`);
-
-                    sendLog(`提取缩略图完成，总耗时: ${Date.now() - thumbStartTime}ms`);
-
-                    return {
-                        format: fileType?.ext ?? 'mp4',
-                        size: fileSize,
-                        width: image.width ?? 100,
-                        height: image.height ?? 100
-                    };
-                } finally {
-                    // 清理资源
-                    try {
-                        ffmpegInstance.fs.unlink(outputFileName);
-                    } catch (error) {
-                        sendLog(`清理输出文件失败: ${(error as Error).message}`);
-                    }
-
-                    try {
-                        ffmpegInstance.fs.unlink(videoFileName);
-                    } catch (error) {
-                        sendLog(`清理视频文件失败: ${(error as Error).message}`);
-                    }
-                }
-            })(),
-
-            // 任务2: 获取视频时长
-            (async () => {
-                const task2StartTime = Date.now();
-                sendLog('开始任务2: 获取视频时长');
-
-                // 创建FFmpeg实例
-                const ffmpegCreateStartTime = Date.now();
-                const ffmpegInstance = await withTimeout(
-                    FFmpeg.create({ core: '@ffmpeg.wasm/core-mt' }),
-                    15000,
-                    '创建FFmpeg实例(时长)'
-                );
-                sendLog(`创建FFmpeg实例完成，耗时: ${Date.now() - ffmpegCreateStartTime}ms`);
-
-                const inputFileName = `${randomUUID()}.mp4`;
-
-                try {
-                    // 写入文件
-                    const writeStartTime = Date.now();
-                    ffmpegInstance.fs.writeFile(inputFileName, readFileSync(videoPath));
-                    sendLog(`写入文件到FFmpeg完成，耗时: ${Date.now() - writeStartTime}ms`);
-
-                    ffmpegInstance.setLogging(true);
-                    let duration = 60; // 默认值
-
-                    ffmpegInstance.setLogger((_level, ...msg) => {
-                        const message = msg.join(' ');
-                        const durationMatch = message.match(/Duration: (\d+):(\d+):(\d+\.\d+)/);
-                        if (durationMatch) {
-                            const hours = parseInt(durationMatch[1] ?? '0', 10);
-                            const minutes = parseInt(durationMatch[2] ?? '0', 10);
-                            const seconds = parseFloat(durationMatch[3] ?? '0');
-                            duration = hours * 3600 + minutes * 60 + seconds;
-                        }
-                    });
-
-                    // 执行FFmpeg
-                    const runStartTime = Date.now();
-                    await withTimeout(
-                        ffmpegInstance.run('-i', inputFileName),
-                        20000,
-                        '获取视频时长'
-                    );
-                    sendLog(`执行FFmpeg命令完成，耗时: ${Date.now() - runStartTime}ms`);
-
-                    sendLog(`任务2(获取视频时长)完成，总耗时: ${Date.now() - task2StartTime}ms`);
-                    return { time: duration };
-                } finally {
-                    try {
-                        ffmpegInstance.fs.unlink(inputFileName);
-                    } catch (error) {
-                        sendLog(`清理输入文件失败: ${(error as Error).message}`);
-                    }
-                }
-            })()
-        ]);
-
-        // 合并结果并返回
-        const totalDuration = Date.now() - startTime;
-        sendLog(`获取视频信息完成，总耗时: ${totalDuration}ms`);
-
-        return {
-            width: fileInfo.width,
-            height: fileInfo.height,
-            time: durationInfo.time,
-            format: fileInfo.format,
-            size: fileInfo.size,
-            filePath: videoPath
-        };
-    }
-}
-type FFmpegMethod = 'extractThumbnail' | 'convertFile' | 'convert' | 'getVideoInfo';
-
-interface FFmpegTask {
-    method: FFmpegMethod;
-    args: any[];
-}
-export default async function handleFFmpegTask({ method, args }: FFmpegTask): Promise<any> {
-    switch (method) {
-    case 'extractThumbnail':
-        return await FFmpegService.extractThumbnail(...args as [string, string]);
-    case 'convertFile':
-        return await FFmpegService.convertFile(...args as [string, string, string]);
-    case 'convert':
-        return await FFmpegService.convert(...args as [string, string]);
-    case 'getVideoInfo':
-        return await FFmpegService.getVideoInfo(...args as [string, string]);
-    default:
-        throw new Error(`Unknown method: ${method}`);
-    }
-}
-recvTask<FFmpegTask>(async ({ method, args }: FFmpegTask) => {
-    return await handleFFmpegTask({ method, args });
-});

src/common/ffmpeg.ts

@@ -1,36 +1,196 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { VideoInfo } from './video';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { runTask } from './worker';
-
-type EncodeArgs = {
-    method: 'extractThumbnail' | 'convertFile' | 'convert' | 'getVideoInfo';
-    args: any[];
+import { readFileSync, statSync, existsSync, mkdirSync } from 'fs';
+import path, { dirname } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import type { VideoInfo } from './video';
+import { fileTypeFromFile } from 'file-type';
+import imageSize from 'image-size';
+import { fileURLToPath } from 'node:url';
+import { platform } from 'node:os';
+const currentPath = dirname(fileURLToPath(import.meta.url));
+const execFileAsync = promisify(execFile);
+const getFFmpegPath = (tool: string): string => {
+    if (process.platform === 'win32') {
+        const exeName = `${tool}.exe`;
+        const isLocalExeExists = existsSync(path.join(currentPath, 'ffmpeg', exeName));
+        return isLocalExeExists ? path.join(currentPath, 'ffmpeg', exeName) : exeName;
+    }
+    return tool;
 };
-
-type EncodeResult = any;
-
-function getWorkerPath() {
-    return path.join(path.dirname(fileURLToPath(import.meta.url)), './ffmpeg-worker.mjs');
-}
-
+export let FFMPEG_CMD = getFFmpegPath('ffmpeg');
+export let FFPROBE_CMD = getFFmpegPath('ffprobe');
+console.log('[Info] ffmpeg:', FFMPEG_CMD);
+console.log('[Info] ffprobe:', FFPROBE_CMD);
 export class FFmpegService {
+    // 确保目标目录存在
+    public static setFfmpegPath(ffmpegPath: string): void {
+        if (platform() === 'win32') {
+            FFMPEG_CMD = path.join(ffmpegPath, 'ffmpeg.exe');
+            FFPROBE_CMD = path.join(ffmpegPath, 'ffprobe.exe');
+            console.log('[Info] ffmpeg:', FFMPEG_CMD);
+            console.log('[Info] ffprobe:', FFPROBE_CMD);
+        }
+    }
+    private static ensureDirExists(filePath: string): void {
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+
     public static async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
-        await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'extractThumbnail', args: [videoPath, thumbnailPath] });
+        try {
+            this.ensureDirExists(thumbnailPath);
+
+            const { stderr } = await execFileAsync(FFMPEG_CMD, [
+                '-i', videoPath,
+                '-ss', '00:00:01.000',
+                '-vframes', '1',
+                '-y', // 覆盖输出文件
+                thumbnailPath
+            ]);
+
+            if (!existsSync(thumbnailPath)) {
+                throw new Error(`提取缩略图失败，输出文件不存在: ${stderr}`);
+            }
+        } catch (error) {
+            console.error('Error extracting thumbnail:', error);
+            throw new Error(`提取缩略图失败: ${(error as Error).message}`);
+        }
     }
 
     public static async convertFile(inputFile: string, outputFile: string, format: string): Promise<void> {
-        await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'convertFile', args: [inputFile, outputFile, format] });
+        try {
+            this.ensureDirExists(outputFile);
+
+            const params = format === 'amr'
+                ? [
+                    '-f', 's16le',
+                    '-ar', '24000',
+                    '-ac', '1',
+                    '-i', inputFile,
+                    '-ar', '8000',
+                    '-b:a', '12.2k',
+                    '-y',
+                    outputFile
+                ]
+                : [
+                    '-f', 's16le',
+                    '-ar', '24000',
+                    '-ac', '1',
+                    '-i', inputFile,
+                    '-y',
+                    outputFile
+                ];
+
+            await execFileAsync(FFMPEG_CMD, params);
+
+            if (!existsSync(outputFile)) {
+                throw new Error('转换失败，输出文件不存在');
+            }
+        } catch (error) {
+            console.error('Error converting file:', error);
+            throw new Error(`文件转换失败: ${(error as Error).message}`);
+        }
     }
 
     public static async convert(filePath: string, pcmPath: string): Promise<Buffer> {
-        const result = await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'convert', args: [filePath, pcmPath] });
-        return result;
+        try {
+            this.ensureDirExists(pcmPath);
+
+            await execFileAsync(FFMPEG_CMD, [
+                '-y',
+                '-i', filePath,
+                '-ar', '24000',
+                '-ac', '1',
+                '-f', 's16le',
+                pcmPath
+            ]);
+
+            if (!existsSync(pcmPath)) {
+                throw new Error('转换PCM失败，输出文件不存在');
+            }
+
+            return readFileSync(pcmPath);
+        } catch (error: any) {
+            throw new Error(`FFmpeg处理转换出错: ${error.message}`);
+        }
     }
 
     public static async getVideoInfo(videoPath: string, thumbnailPath: string): Promise<VideoInfo> {
-        const result = await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'getVideoInfo', args: [videoPath, thumbnailPath] });
-        return result;
+        try {
+            // 并行执行获取文件信息和提取缩略图
+            const [fileInfo, duration] = await Promise.all([
+                this.getFileInfo(videoPath, thumbnailPath),
+                this.getVideoDuration(videoPath)
+            ]);
+
+            const result: VideoInfo = {
+                width: fileInfo.width,
+                height: fileInfo.height,
+                time: duration,
+                format: fileInfo.format,
+                size: fileInfo.size,
+                filePath: videoPath
+            };
+            return result;
+        } catch (error) {
+            throw error;
+        }
     }
-}
+
+    private static async getFileInfo(videoPath: string, thumbnailPath: string): Promise<{
+        format: string,
+        size: number,
+        width: number,
+        height: number
+    }> {
+
+        // 获取文件大小和类型
+        const [fileType, fileSize] = await Promise.all([
+            fileTypeFromFile(videoPath).catch(() => {
+                return null;
+            }),
+            Promise.resolve(statSync(videoPath).size)
+        ]);
+
+
+        try {
+            await this.extractThumbnail(videoPath, thumbnailPath);
+            // 获取图片尺寸
+            const dimensions = imageSize(thumbnailPath);
+
+            return {
+                format: fileType?.ext ?? 'mp4',
+                size: fileSize,
+                width: dimensions.width ?? 100,
+                height: dimensions.height ?? 100
+            };
+        } catch (error) {
+            return {
+                format: fileType?.ext ?? 'mp4',
+                size: fileSize,
+                width: 100,
+                height: 100
+            };
+        }
+    }
+
+    private static async getVideoDuration(videoPath: string): Promise<number> {
+        try {
+            // 使用FFprobe获取时长
+            const { stdout } = await execFileAsync(FFPROBE_CMD, [
+                '-v', 'error',
+                '-show_entries', 'format=duration',
+                '-of', 'default=noprint_wrappers=1:nokey=1',
+                videoPath
+            ]);
+
+            const duration = parseFloat(stdout.trim());
+
+            return isNaN(duration) ? 60 : duration;
+        } catch (error) {
+            return 60; // 默认时长
+        }
+    }
+}

src/common/version.ts

@@ -1 +1 @@
-export const napCatVersion = '4.7.23';
+export const napCatVersion = '4.7.25';

src/framework/napcat.ts

@@ -9,6 +9,8 @@ import { NodeIKernelLoginService } from '@/core/services';
 import { NodeIQQNTWrapperSession, WrapperNodeApi } from '@/core/wrapper';
 import { InitWebUi, WebUiConfig, webUiRuntimePort } from '@/webui';
 import { NapCatOneBot11Adapter } from '@/onebot';
+import { downloadFFmpegIfNotExists } from '@/common/download-ffmpeg';
+import { FFmpegService } from '@/common/ffmpeg';
 
 //Framework ES入口文件
 export async function getWebUiUrl() {
@@ -36,6 +38,11 @@ export async function NCoreInitFramework(
     const logger = new LogWrapper(pathWrapper.logsPath);
     const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
     const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVesion());
+    downloadFFmpegIfNotExists(logger).then(({ path, isExist }) => {
+        if (!isExist && path) {
+            FFmpegService.setFfmpegPath(path);
+        }
+    });
     //直到登录成功后，执行下一步
     const selfInfo = await new Promise<SelfInfo>((resolveSelfInfo) => {
         const loginListener = new NodeIKernelLoginListener();

src/shell/base.ts

@@ -31,6 +31,8 @@ import { WebUiDataRuntime } from '@/webui/src/helper/Data';
 import { napCatVersion } from '@/common/version';
 import { NodeIO3MiscListener } from '@/core/listeners/NodeIO3MiscListener';
 import { sleep } from '@/common/helper';
+import { downloadFFmpegIfNotExists } from '@/common/download-ffmpeg';
+import { FFmpegService } from '@/common/ffmpeg';
 
 // NapCat Shell App ES 入口文件
 async function handleUncaughtExceptions(logger: LogWrapper) {
@@ -311,6 +313,11 @@ export async function NCoreInitShell() {
     const pathWrapper = new NapCatPathWrapper();
     const logger = new LogWrapper(pathWrapper.logsPath);
     handleUncaughtExceptions(logger);
+    downloadFFmpegIfNotExists(logger).then(({ path, isExist }) => {
+    if (!isExist && path) {
+        FFmpegService.setFfmpegPath(path);
+    }
+});
     const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
     const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVesion());
 

src/shell/napcat.ts

@@ -1,7 +1,6 @@
 import { NCoreInitShell } from './base';
-import * as net from 'net'; // 引入 net 模块
+import * as net from 'net';
 import * as process from 'process';
-
 if (process.platform === 'win32') {
     const pid = process.pid;
     const pipePath = `\\\\.\\pipe\\NapCat_${pid}`;

vite.config.ts

@@ -7,8 +7,7 @@ import { builtinModules } from 'module';
 const external = [
     'silk-wasm',
     'ws',
-    'express',
-    '@ffmpeg.wasm/core-mt'
+    'express'
 ];
 const nodeModules = [...builtinModules, builtinModules.map((m) => `node:${m}`)].flat();
 
@@ -97,7 +96,6 @@ const UniversalBaseConfig = () =>
                 entry: {
                     napcat: 'src/universal/napcat.ts',
                     'audio-worker': 'src/common/audio-worker.ts',
-                    'ffmpeg-worker': 'src/common/ffmpeg-worker.ts',
                     'worker/conoutSocketWorker': 'src/pty/worker/conoutSocketWorker.ts',
                 },
                 formats: ['es'],
@@ -127,7 +125,6 @@ const ShellBaseConfig = () =>
                 entry: {
                     napcat: 'src/shell/napcat.ts',
                     'audio-worker': 'src/common/audio-worker.ts',
-                    'ffmpeg-worker': 'src/common/ffmpeg-worker.ts',
                     'worker/conoutSocketWorker': 'src/pty/worker/conoutSocketWorker.ts',
                 },
                 formats: ['es'],
@@ -157,7 +154,6 @@ const FrameworkBaseConfig = () =>
                 entry: {
                     napcat: 'src/framework/napcat.ts',
                     'audio-worker': 'src/common/audio-worker.ts',
-                    'ffmpeg-worker': 'src/common/ffmpeg-worker.ts',
                     'worker/conoutSocketWorker': 'src/pty/worker/conoutSocketWorker.ts',
                 },
                 formats: ['es'],