fix: 一些问题

manifest.json

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

package.json

@@ -2,7 +2,7 @@
   "name": "napcat",
   "private": true,
   "type": "module",
-  "version": "4.7.24",
+  "version": "4.7.29",
   "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",

src/common/download-ffmpeg.ts

@@ -0,0 +1,352 @@
+// 更正导入语句
+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;
+    }
+}
+
+/**
+ * 检查系统PATH环境变量中是否存在指定可执行文件
+ * @param executable 可执行文件名
+ * @returns 如果找到返回完整路径，否则返回null
+ */
+function findExecutableInPath(executable: string): string | null {
+    // 仅适用于Windows系统
+    if (os.platform() !== 'win32') return null;
+
+    // 获取PATH环境变量
+    const pathEnv = process.env['PATH'] || '';
+    const pathDirs = pathEnv.split(';');
+
+    // 检查每个目录
+    for (const dir of pathDirs) {
+        if (!dir) continue;
+        try {
+            const filePath = path.join(dir, executable);
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+        } catch (error) {
+            continue;
+        }
+    }
+
+    return null;
+}
+
+export async function downloadFFmpegIfNotExists(log: LogWrapper) {
+    // 仅限Windows
+    if (os.platform() !== 'win32') {
+        return {
+            path: null,
+            reset: false
+        };
+    }
+    const ffmpegInPath = findExecutableInPath('ffmpeg.exe');
+    const ffprobeInPath = findExecutableInPath('ffprobe.exe');
+
+    if (ffmpegInPath && ffprobeInPath) {
+        const ffmpegDir = path.dirname(ffmpegInPath);
+        return {
+            path: ffmpegDir,
+            reset: true
+        };
+    }
+
+    // 如果环境变量中没有，检查项目目录中是否存在
+    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(path.join(currentPath, 'ffmpeg'), path.join(currentPath, 'cache'), (percentage: number, message: string) => {
+            log.log(`[FFmpeg] [Download] ${percentage}% - ${message}`);
+        });
+        return {
+            path: path.join(currentPath, 'ffmpeg'),
+            reset: true
+        }
+    }
+
+    return {
+        path: path.join(currentPath, 'ffmpeg'),
+        reset: true
+    }
+}

src/common/ffmpeg.ts

@@ -1,16 +1,35 @@
 import { readFileSync, statSync, existsSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
+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';
+import { LogWrapper } from './log';
+const currentPath = dirname(fileURLToPath(import.meta.url));
 const execFileAsync = promisify(execFile);
-const FFMPEG_CMD = process.platform === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
-const FFPROBE_CMD = process.platform === 'win32' ? 'ffprobe.exe' : 'ffprobe';
-
+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;
+};
+export let FFMPEG_CMD = getFFmpegPath('ffmpeg');
+export let FFPROBE_CMD = getFFmpegPath('ffprobe');
 export class FFmpegService {
     // 确保目标目录存在
+    public static setFfmpegPath(ffmpegPath: string,logger:LogWrapper): void {
+        if (platform() === 'win32') {
+            FFMPEG_CMD = path.join(ffmpegPath, 'ffmpeg.exe');
+            FFPROBE_CMD = path.join(ffmpegPath, 'ffprobe.exe');
+            logger.log('[Check] ffmpeg:', FFMPEG_CMD);
+            logger.log('[Check] ffprobe:', FFPROBE_CMD);
+        }
+    }
     private static ensureDirExists(filePath: string): void {
         const dir = dirname(filePath);
         if (!existsSync(dir)) {

src/common/version.ts

@@ -1 +1 @@
-export const napCatVersion = '4.7.24';
+export const napCatVersion = '4.7.29';

src/core/external/appid.json

@@ -242,5 +242,9 @@
     "3.2.17-34231": {
         "appid": 537279245,
         "qua": "V1_LNX_NQ_3.2.17_34231_GW_B"
+    },
+    "9.9.19-34362": {
+        "appid": 537279260,
+        "qua": "V1_WIN_NQ_9.9.19_34362_GW_B"
     }
 }

src/core/external/offset.json

@@ -326,5 +326,9 @@
     "3.2.17-34231-arm64": {
         "send": "770CDC0",
         "recv": "77106F0"
+    },
+    "9.9.19-34362-x64":{
+        "send": "3BD80D0",
+        "recv": "3BDC8D0"
     }
 }

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,13 @@ export async function NCoreInitFramework(
     const logger = new LogWrapper(pathWrapper.logsPath);
     const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
     const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVesion());
+    downloadFFmpegIfNotExists(logger).then(({ path, reset }) => {
+        if (reset && path) {
+            FFmpegService.setFfmpegPath(path,logger);
+        }
+    }).catch(e => {
+        logger.logError('[Ffmpeg] Error:', e);
+    });
     //直到登录成功后，执行下一步
     const selfInfo = await new Promise<SelfInfo>((resolveSelfInfo) => {
         const loginListener = new NodeIKernelLoginListener();

src/shell/base.ts

@@ -31,7 +31,9 @@ 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';
+import { connectToNamedPipe } from '@/shell/pipe';
 // NapCat Shell App ES 入口文件
 async function handleUncaughtExceptions(logger: LogWrapper) {
     process.on('uncaughtException', (err) => {
@@ -220,7 +222,7 @@ async function handleLoginInner(context: { isLogined: boolean }, logger: LogWrap
             logger.log(`可用于快速登录的 QQ：\n${historyLoginList
                 .map((u, index) => `${index + 1}. ${u.uin} ${u.nickName}`)
                 .join('\n')
-            }`);
+                }`);
         }
         loginService.getQRCodePicture();
         try {
@@ -311,6 +313,14 @@ export async function NCoreInitShell() {
     const pathWrapper = new NapCatPathWrapper();
     const logger = new LogWrapper(pathWrapper.logsPath);
     handleUncaughtExceptions(logger);
+    await connectToNamedPipe(logger).catch(e => logger.logError('命名管道连接失败', e));
+    downloadFFmpegIfNotExists(logger).then(({ path, reset }) => {
+        if (reset && path) {
+            FFmpegService.setFfmpegPath(path, logger);
+        }
+    }).catch(e => {
+        logger.logError('[Ffmpeg] Error:', e);
+    });
     const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
     const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVesion());
 

src/shell/napcat.ts

@@ -1,37 +1,2 @@
 import { NCoreInitShell } from './base';
-import * as net from 'net'; // 引入 net 模块
-import * as process from 'process';
-
-if (process.platform === 'win32') {
-    const pid = process.pid;
-    const pipePath = `\\\\.\\pipe\\NapCat_${pid}`;
-    try {
-        const pipeSocket = net.connect(pipePath, () => {
-            console.log(`已连接到命名管道: ${pipePath}`);
-            process.stdout.write = (
-                chunk: any,
-                encoding?: BufferEncoding | (() => void),
-                cb?: () => void
-            ): boolean => {
-                if (typeof encoding === 'function') {
-                    cb = encoding;
-                    encoding = undefined;
-                }
-                return pipeSocket.write(chunk, encoding as BufferEncoding, cb);
-            };
-            console.log(`stdout 已重定向到命名管道: ${pipePath}`);
-        });
-
-        pipeSocket.on('error', (err) => {
-            console.log(`连接命名管道 ${pipePath} 时出错:`, err);
-        });
-
-        pipeSocket.on('end', () => {
-            console.log('命名管道连接已关闭');
-        });
-
-    } catch (error) {
-        console.log(`尝试连接命名管道 ${pipePath} 时发生异常:`, error);
-    }
-}
 NCoreInitShell();

src/shell/pipe.ts

@@ -0,0 +1,74 @@
+import { LogWrapper } from '@/common/log';
+import * as net from 'net';
+import * as process from 'process';
+
+/**
+ * 连接到命名管道并重定向stdout
+ * @param logger 日志记录器
+ * @param timeoutMs 连接超时时间(毫秒)，默认5000ms
+ * @returns Promise，连接成功时resolve，失败时reject
+ */
+export function connectToNamedPipe(logger: LogWrapper, timeoutMs: number = 5000): Promise<{ disconnect: () => void }> {
+    return new Promise((resolve, reject) => {
+        if (process.platform !== 'win32') {
+            logger.log('只有Windows平台支持命名管道');
+            // 非Windows平台不reject，而是返回一个空的disconnect函数
+            return resolve({ disconnect: () => { } });
+        }
+
+        const pid = process.pid;
+        const pipePath = `\\\\.\\pipe\\NapCat_${pid}`;
+
+        // 设置连接超时
+        const timeoutId = setTimeout(() => {
+            reject(new Error(`连接命名管道超时: ${pipePath}`));
+        }, timeoutMs);
+
+        try {
+            let originalStdoutWrite = process.stdout.write.bind(process.stdout);
+            const pipeSocket = net.connect(pipePath, () => {
+                // 清除超时
+                clearTimeout(timeoutId);
+
+                logger.log(`[StdOut] 已重定向到命名管道: ${pipePath}`);
+                process.stdout.write = (
+                    chunk: any,
+                    encoding?: BufferEncoding | (() => void),
+                    cb?: () => void
+                ): boolean => {
+                    if (typeof encoding === 'function') {
+                        cb = encoding;
+                        encoding = undefined;
+                    }
+                    return pipeSocket.write(chunk, encoding as BufferEncoding, cb);
+                };
+                // 提供断开连接的方法
+                const disconnect = () => {
+                    process.stdout.write = originalStdoutWrite;
+                    pipeSocket.end();
+                    logger.log(`已手动断开命名管道连接: ${pipePath}`);
+                };
+
+                // 返回成功和断开连接的方法
+                resolve({ disconnect });
+            });
+
+            pipeSocket.on('error', (err) => {
+                clearTimeout(timeoutId);
+                process.stdout.write = originalStdoutWrite;
+                logger.log(`连接命名管道 ${pipePath} 时出错:`, err);
+                reject(err);
+            });
+
+            pipeSocket.on('end', () => {
+                process.stdout.write = originalStdoutWrite;
+                logger.log('命名管道连接已关闭');
+            });
+
+        } catch (error) {
+            clearTimeout(timeoutId);
+            logger.log(`尝试连接命名管道 ${pipePath} 时发生异常:`, error);
+            reject(error);
+        }
+    });
+}