feat: websocket server

README.md

@@ -37,7 +37,7 @@ _Modern protocol-side framework implemented based on NTQQ._
 | Docs | [![Github.IO](https://img.shields.io/badge/docs%20on-Github.IO-orange)](https://napneko.github.io/) | [![Cloudflare.Worker](https://img.shields.io/badge/docs%20on-Cloudflare.Worker-black)](https://doc.napneko.icu/) | [![Cloudflare.HKServer](https://img.shields.io/badge/docs%20on-Cloudflare.HKServer-informational)](https://napcat.napneko.icu/) |
 |:-:|:-:|:-:|:-:|
 
-| Docs | [![Cloudflare.Pages](https://img.shields.io/badge/docs%20on-Cloudflare.Pages-blue)](https://napneko.pages.dev/) | [![Server.Other](https://img.shields.io/badge/docs%20on-Server.Other-green)](https://napcat.cyou/) | [![NapCat.Wiki](https://img.shields.io/badge/docs%20on-NapCat.Wiki-red)](https://www.napcat.wiki) |
+| Docs | [![Cloudflare.Pages](https://img.shields.io/badge/docs%20on-Cloudflare.Pages-blue)](https://napneko.pages.dev/) | [![Server.Other](https://img.shields.io/badge/docs%20on-Server.Other-green)](https://docs.napcat.cyou/) | [![NapCat.Wiki](https://img.shields.io/badge/docs%20on-NapCat.Wiki-red)](https://www.napcat.wiki) |
 |:-:|:-:|:-:|:-:|
 
 | Contact | [![QQ Group#1](https://img.shields.io/badge/QQ%20Group%231-Join-blue)](https://qm.qq.com/q/I6LU87a0Yq) | [![QQ Group#2](https://img.shields.io/badge/QQ%20Group%232-Join-blue)](https://qm.qq.com/q/HaRcfrHpUk) | [![Telegram](https://img.shields.io/badge/Telegram-MelodicMoonlight-blue)](https://t.me/MelodicMoonlight) |
@@ -47,6 +47,8 @@ _Modern protocol-side framework implemented based on NTQQ._
 
 + [Lagrange](https://github.com/LagrangeDev/Lagrange.Core) 对本项目的大力支持 参考部分代码 已获授权
 
++ [LLOneBot](https://github.com/LLOneBot/LLOneBot) 相关的开发曾参与本项目部分开发
+
 + 不过最最重要的 还是需要感谢屏幕前的你哦~
 
 ---
@@ -58,7 +60,3 @@ _Modern protocol-side framework implemented based on NTQQ._
 2. 项目其余逻辑代码采用[本仓库开源许可](./LICENSE).
 
 **本仓库仅用于提高易用性，实现消息推送类功能，此外，禁止任何项目未经仓库主作者授权基于 NapCat 代码开发。使用请遵守当地法律法规，由此造成的问题由使用者和提供违规使用教程者负责。**
-
-## Warnings
-
-[某框架抄袭部分分析](https://napneko.github.io/other/about-copy)

launcher/qqnt.json

@@ -1,9 +1,9 @@
 {
   "name": "qq-chat",
-  "version": "9.9.18-32869",
+  "version": "9.9.18-32793",
-  "verHash": "e735296c",
+  "verHash": "d43f097e",
-  "linuxVersion": "3.2.16-32869",
+  "linuxVersion": "3.2.16-32793",
-  "linuxVerHash": "4c192ba9",
+  "linuxVerHash": "ee4bd910",
   "private": true,
   "description": "QQ",
   "productName": "QQ",
@@ -34,9 +34,9 @@
       "vuex@4.1.0": "patches/vuex@4.1.0.patch"
     }
   },
-  "buildVersion": "32869",
+  "buildVersion": "32793",
   "isPureShell": true,
   "isByteCodeShell": true,
   "platform": "win32",
   "eleArch": "x64"
-}
+}

manifest.json

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

napcat.webui/package.json

@@ -55,7 +55,6 @@
     "ahooks": "^3.8.4",
     "axios": "^1.7.9",
     "clsx": "^2.1.1",
-    "crypto-js": "^4.2.0",
     "echarts": "^5.5.1",
     "event-source-polyfill": "^1.0.31",
     "framer-motion": "^12.0.6",
@@ -89,7 +88,6 @@
     "@eslint/js": "^9.19.0",
     "@react-types/shared": "^3.26.0",
     "@trivago/prettier-plugin-sort-imports": "^5.2.2",
-    "@types/crypto-js": "^4.2.2",
     "@types/event-source-polyfill": "^1.0.5",
     "@types/fabric": "^5.3.9",
     "@types/node": "^22.12.0",

napcat.webui/src/controllers/webui_manager.ts

@@ -3,7 +3,7 @@ import { EventSourcePolyfill } from 'event-source-polyfill'
 import { LogLevel } from '@/const/enum'
 
 import { serverRequest } from '@/utils/request'
-import CryptoJS from "crypto-js";
+
 export interface Log {
   level: LogLevel
   message: string
@@ -17,10 +17,9 @@ export default class WebUIManager {
   }
 
   public static async loginWithToken(token: string) {
-    const sha256 = CryptoJS.SHA256(token + '.napcat').toString();
     const { data } = await serverRequest.post<ServerResponse<AuthResponse>>(
       '/auth/login',
-      { hash: sha256 }
+      { token }
     )
     return data.data.Credential
   }

napcat.webui/src/pages/web_login.tsx

@@ -47,22 +47,6 @@ export default function WebLoginPage() {
     }
   }
 
-  // 处理全局键盘事件
-  const handleKeyDown = (e: KeyboardEvent) => {
-    if (e.key === 'Enter' && !isLoading) {
-      onSubmit()
-    }
-  }
-
-  useEffect(() => {
-    document.addEventListener('keydown', handleKeyDown)
-
-    // 清理函数
-    return () => {
-      document.removeEventListener('keydown', handleKeyDown)
-    }
-  }, [tokenValue, isLoading]) // 依赖项包含用于登录的状态
-
   useEffect(() => {
     if (token) {
       onSubmit()
@@ -95,7 +79,6 @@ export default function WebLoginPage() {
             <CardBody className="flex gap-5 py-5 px-5 md:px-10">
               <Input
                 isClearable
-                type="password"
                 classNames={{
                   label: 'text-black/50 dark:text-white/90',
                   input: [

package.json

@@ -2,7 +2,7 @@
   "name": "napcat",
   "private": true,
   "type": "module",
-  "version": "4.7.33",
+  "version": "4.7.6",
   "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,9 @@
     "@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",
+    "@hono/node-server": "^1.13.8",
     "@log4js-node/log4js-api": "^1.0.2",
     "@napneko/nap-proto-core": "^0.0.4",
     "@rollup/plugin-node-resolve": "^16.0.0",
@@ -41,6 +43,7 @@
     "ajv": "^8.13.0",
     "async-mutex": "^0.5.0",
     "commander": "^13.0.0",
+    "compressing": "^1.10.1",
     "cors": "^2.8.5",
     "esbuild": "0.25.0",
     "eslint": "^9.14.0",
@@ -50,21 +53,20 @@
     "fast-xml-parser": "^4.3.6",
     "file-type": "^20.0.0",
     "globals": "^16.0.0",
+    "hono": "^4.7.2",
     "image-size": "^1.1.1",
     "json5": "^2.2.3",
     "multer": "^1.4.5-lts.1",
+    "napcat.protobuf": "^1.1.3",
     "typescript": "^5.3.3",
     "typescript-eslint": "^8.13.0",
     "vite": "^6.0.1",
-    "vite-plugin-cp": "^6.0.0",
+    "vite-plugin-cp": "^4.0.8",
+    "vite-plugin-wasm": "^3.4.1",
     "vite-tsconfig-paths": "^5.1.0",
-    "napcat.protobuf": "^1.1.4",
-    "winston": "^3.17.0",
-    "compressing": "^1.10.1"
-  },
-  "dependencies": {
-    "express": "^5.0.0",
     "silk-wasm": "^3.6.1",
-    "ws": "^8.18.0"
+    "@hono/node-ws": "^1.1.0",
-  }
+    "winston": "^3.17.0"
-}
+  },
+  "dependencies": {}
+}

src/common/clean-task.ts

@@ -1,229 +0,0 @@
-import fs from 'fs';
-// generate Claude 3.7 Sonet Thinking
-
-interface FileRecord {
-    filePath: string;
-    addedTime: number;
-    retries: number;
-}
-
-interface CleanupTask {
-    fileRecord: FileRecord;
-    timer: NodeJS.Timeout;
-}
-
-class CleanupQueue {
-    private tasks: Map<string, CleanupTask> = new Map();
-    private readonly MAX_RETRIES = 3;
-    private isProcessing: boolean = false;
-    private pendingOperations: Array<() => void> = [];
-
-    /**
-     * 执行队列中的待处理操作，确保异步安全
-     */
-    private executeNextOperation(): void {
-        if (this.pendingOperations.length === 0) {
-            this.isProcessing = false;
-            return;
-        }
-
-        this.isProcessing = true;
-        const operation = this.pendingOperations.shift();
-        operation?.();
-
-        // 使用 setImmediate 允许事件循环继续，防止阻塞
-        setImmediate(() => this.executeNextOperation());
-    }
-
-    /**
-     * 安全执行操作，防止竞态条件
-     * @param operation 要执行的操作
-     */
-    private safeExecute(operation: () => void): void {
-        this.pendingOperations.push(operation);
-        if (!this.isProcessing) {
-            this.executeNextOperation();
-        }
-    }
-
-    /**
-     * 检查文件是否存在
-     * @param filePath 文件路径
-     * @returns 文件是否存在
-     */
-    private fileExists(filePath: string): boolean {
-        try {
-            return fs.existsSync(filePath);
-        } catch (error) {
-            //console.log(`检查文件存在出错: ${filePath}`, error);
-            return false;
-        }
-    }
-
-    /**
-     * 添加文件到清理队列
-     * @param filePath 文件路径
-     * @param cleanupDelay 清理延迟时间(毫秒)
-     */
-    addFile(filePath: string, cleanupDelay: number): void {
-        this.safeExecute(() => {
-            // 如果文件已在队列中，取消原来的计时器
-            if (this.tasks.has(filePath)) {
-                this.cancelCleanup(filePath);
-            }
-
-            // 创建新的文件记录
-            const fileRecord: FileRecord = {
-                filePath,
-                addedTime: Date.now(),
-                retries: 0
-            };
-
-            // 设置计时器
-            const timer = setTimeout(() => {
-                this.cleanupFile(fileRecord, cleanupDelay);
-            }, cleanupDelay);
-
-            // 添加到任务队列
-            this.tasks.set(filePath, { fileRecord, timer });
-        });
-    }
-
-    /**
-     * 批量添加文件到清理队列
-     * @param filePaths 文件路径数组
-     * @param cleanupDelay 清理延迟时间(毫秒)
-     */
-    addFiles(filePaths: string[], cleanupDelay: number): void {
-        this.safeExecute(() => {
-            for (const filePath of filePaths) {
-                // 内部直接处理，不通过 safeExecute 以保证批量操作的原子性
-                if (this.tasks.has(filePath)) {
-                    // 取消已有的计时器，但不使用 cancelCleanup 方法以避免重复的安全检查
-                    const existingTask = this.tasks.get(filePath);
-                    if (existingTask) {
-                        clearTimeout(existingTask.timer);
-                    }
-                }
-
-                const fileRecord: FileRecord = {
-                    filePath,
-                    addedTime: Date.now(),
-                    retries: 0
-                };
-
-                const timer = setTimeout(() => {
-                    this.cleanupFile(fileRecord, cleanupDelay);
-                }, cleanupDelay);
-
-                this.tasks.set(filePath, { fileRecord, timer });
-            }
-        });
-    }
-
-    /**
-     * 清理文件
-     * @param record 文件记录
-     * @param delay 延迟时间，用于重试
-     */
-    private cleanupFile(record: FileRecord, delay: number): void {
-        this.safeExecute(() => {
-            // 首先检查文件是否存在，不存在则视为清理成功
-            if (!this.fileExists(record.filePath)) {
-                //console.log(`文件已不存在，跳过清理: ${record.filePath}`);
-                this.tasks.delete(record.filePath);
-                return;
-            }
-
-            try {
-                // 尝试删除文件
-                fs.unlinkSync(record.filePath);
-                // 删除成功，从队列中移除任务
-                this.tasks.delete(record.filePath);
-            } catch (error) {
-                const err = error as NodeJS.ErrnoException;
-
-                // 明确处理文件不存在的情况
-                if (err.code === 'ENOENT') {
-                    //console.log(`文件在删除时不存在，视为清理成功: ${record.filePath}`);
-                    this.tasks.delete(record.filePath);
-                    return;
-                }
-
-                // 文件没有访问权限等情况
-                if (err.code === 'EACCES' || err.code === 'EPERM') {
-                    //console.error(`没有权限删除文件: ${record.filePath}`, err);
-                }
-
-                // 其他删除失败情况，考虑重试
-                if (record.retries < this.MAX_RETRIES - 1) {
-                    // 还有重试机会，增加重试次数
-                    record.retries++;
-                    //console.log(`清理文件失败，将重试(${record.retries}/${this.MAX_RETRIES}): ${record.filePath}`);
-
-                    // 设置相同的延迟时间再次尝试
-                    const timer = setTimeout(() => {
-                        this.cleanupFile(record, delay);
-                    }, delay);
-
-                    // 更新任务
-                    this.tasks.set(record.filePath, { fileRecord: record, timer });
-                } else {
-                    // 已达到最大重试次数，从队列中移除任务
-                    this.tasks.delete(record.filePath);
-                    //console.error(`清理文件失败，已达最大重试次数(${this.MAX_RETRIES}): ${record.filePath}`, error);
-                }
-            }
-        });
-    }
-
-    /**
-     * 取消文件的清理任务
-     * @param filePath 文件路径
-     * @returns 是否成功取消
-     */
-    cancelCleanup(filePath: string): boolean {
-        let cancelled = false;
-        this.safeExecute(() => {
-            const task = this.tasks.get(filePath);
-            if (task) {
-                clearTimeout(task.timer);
-                this.tasks.delete(filePath);
-                cancelled = true;
-            }
-        });
-        return cancelled;
-    }
-
-    /**
-     * 获取队列中的文件数量
-     * @returns 文件数量
-     */
-    getQueueSize(): number {
-        return this.tasks.size;
-    }
-
-    /**
-     * 获取所有待清理的文件
-     * @returns 文件路径数组
-     */
-    getPendingFiles(): string[] {
-        return Array.from(this.tasks.keys());
-    }
-
-    /**
-     * 清空所有清理任务
-     */
-    clearAll(): void {
-        this.safeExecute(() => {
-            // 取消所有定时器
-            for (const task of this.tasks.values()) {
-                clearTimeout(task.timer);
-            }
-            this.tasks.clear();
-            //console.log('已清空所有清理任务');
-        });
-    }
-}
-
-export const cleanTaskQueue = new CleanupQueue();

src/common/download-ffmpeg.ts

@@ -1,352 +0,0 @@
-// 更正导入语句
-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-worker.ts

@@ -0,0 +1,165 @@
+/* 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 });
+        }
+    });
+}
+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> {
+        await FFmpegService.extractThumbnail(videoPath, thumbnailPath);
+        const fileType = (await fileTypeFromFile(videoPath))?.ext ?? 'mp4';
+        const inputFileName = `${randomUUID()}.${fileType}`;
+        const ffmpegInstance = await FFmpeg.create({ core: '@ffmpeg.wasm/core-mt' });
+        ffmpegInstance.fs.writeFile(inputFileName, readFileSync(videoPath));
+        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;
+            }
+        });
+        await ffmpegInstance.run('-i', inputFileName);
+        const image = imageSize(thumbnailPath);
+        ffmpegInstance.fs.unlink(inputFileName);
+        const fileSize = statSync(videoPath).size;
+        return {
+            width: image.width ?? 100,
+            height: image.height ?? 100,
+            time: duration,
+            format: fileType,
+            size: fileSize,
+            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,195 +1,36 @@
-import { readFileSync, statSync, existsSync, mkdirSync } from 'fs';
+/* eslint-disable @typescript-eslint/no-explicit-any */
-import path, { dirname } from 'path';
+import { VideoInfo } from './video';
-import { execFile } from 'child_process';
+import path from 'path';
-import { promisify } from 'util';
+import { fileURLToPath } from 'url';
-import type { VideoInfo } from './video';
+import { runTask } from './worker';
-import { fileTypeFromFile } from 'file-type';
+
-import imageSize from 'image-size';
+type EncodeArgs = {
-import { fileURLToPath } from 'node:url';
+    method: 'extractThumbnail' | 'convertFile' | 'convert' | 'getVideoInfo';
-import { platform } from 'node:os';
+    args: any[];
-import { LogWrapper } from './log';
-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;
 };
-export let FFMPEG_CMD = getFFmpegPath('ffmpeg');
+
-export let FFPROBE_CMD = getFFmpegPath('ffprobe');
+type EncodeResult = any;
+
+function getWorkerPath() {
+    return path.join(path.dirname(fileURLToPath(import.meta.url)), './ffmpeg-worker.mjs');
+}
+
 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)) {
-            mkdirSync(dir, { recursive: true });
-        }
-    }
-
     public static async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
-        try {
+        await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'extractThumbnail', args: [videoPath, thumbnailPath] });
-            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> {
-        try {
+        await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'convertFile', args: [inputFile, outputFile, format] });
-            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> {
-        try {
+        const result = await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'convert', args: [filePath, pcmPath] });
-            this.ensureDirExists(pcmPath);
+        return result;
-
-            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> {
-        try {
+        const result = await await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { method: 'getVideoInfo', args: [videoPath, thumbnailPath] });
-            // 并行执行获取文件信息和提取缩略图
+        return result;
-            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/file.ts

@@ -76,7 +76,7 @@ export function calculateFileMD5(filePath: string): Promise<string> {
         const stream = fs.createReadStream(filePath);
         const hash = crypto.createHash('md5');
 
-        stream.on('data', (data) => {
+        stream.on('data', (data: Buffer) => {
             // 当读取到数据时，更新哈希对象的状态
             hash.update(data);
         });
@@ -182,28 +182,28 @@ export async function uriToLocalFile(dir: string, uri: string, filename: string
     const filePath = path.join(dir, filename);
 
     switch (UriType) {
-        case FileUriType.Local: {
+    case FileUriType.Local: {
-            const fileExt = path.extname(HandledUri);
+        const fileExt = path.extname(HandledUri);
-            const localFileName = path.basename(HandledUri, fileExt) + fileExt;
+        const localFileName = path.basename(HandledUri, fileExt) + fileExt;
-            const tempFilePath = path.join(dir, filename + fileExt);
+        const tempFilePath = path.join(dir, filename + fileExt);
-            fs.copyFileSync(HandledUri, tempFilePath);
+        fs.copyFileSync(HandledUri, tempFilePath);
-            return { success: true, errMsg: '', fileName: localFileName, path: tempFilePath };
+        return { success: true, errMsg: '', fileName: localFileName, path: tempFilePath };
-        }
+    }
 
-        case FileUriType.Remote: {
+    case FileUriType.Remote: {
-            const buffer = await httpDownload({ url: HandledUri, headers: headers ?? {} });
+        const buffer = await httpDownload({ url: HandledUri, headers: headers ?? {} });
-            fs.writeFileSync(filePath, buffer);
+        fs.writeFileSync(filePath, buffer);
-            return { success: true, errMsg: '', fileName: filename, path: filePath };
+        return { success: true, errMsg: '', fileName: filename, path: filePath };
-        }
+    }
 
-        case FileUriType.Base64: {
+    case FileUriType.Base64: {
-            const base64 = HandledUri.replace(/^base64:\/\//, '');
+        const base64 = HandledUri.replace(/^base64:\/\//, '');
-            const base64Buffer = Buffer.from(base64, 'base64');
+        const base64Buffer = Buffer.from(base64, 'base64');
-            fs.writeFileSync(filePath, base64Buffer);
+        fs.writeFileSync(filePath, base64Buffer);
-            return { success: true, errMsg: '', fileName: filename, path: filePath };
+        return { success: true, errMsg: '', fileName: filename, path: filePath };
-        }
+    }
 
-        default:
+    default:
-            return { success: false, errMsg: `识别URL失败, uri= ${uri}`, fileName: '', path: '' };
+        return { success: false, errMsg: `识别URL失败, uri= ${uri}`, fileName: '', path: '' };
     }
 }

src/common/version.ts

@@ -1 +1 @@
-export const napCatVersion = '4.7.33';
+export const napCatVersion = '4.7.6';

src/common/worker.ts

@@ -5,12 +5,6 @@ export async function runTask<T, R>(workerScript: string, taskData: T): Promise<
     try {
         return await new Promise<R>((resolve, reject) => {
             worker.on('message', (result: R) => {
-                if ((result as any)?.log) {
-                    console.error('Worker Log--->:', (result as { log: string }).log);
-                }
-                if ((result as any)?.error) {
-                    reject(new Error("Worker error: " + (result as { error: string }).error));
-                }
                 resolve(result);
             });
 

src/core/apis/file.ts

@@ -41,10 +41,10 @@ export class NTQQFileApi {
         this.context = context;
         this.core = core;
         this.rkeyManager = new RkeyManager([
-            'https://secret-service.bietiaop.com/rkeys',
+            'https://ss.xingzhige.com/music_card/rkey', // 国内
-            'http://ss.xingzhige.com/music_card/rkey',
+            'https://secret-service.bietiaop.com/rkeys',//国内
         ],
-            this.context.logger
+        this.context.logger
         );
     }
 
@@ -182,30 +182,23 @@ export class NTQQFileApi {
         filePath = newFilePath;
 
         const { fileName: _fileName, path, fileSize, md5 } = await this.core.apis.FileApi.uploadFile(filePath, ElementType.VIDEO);
-        context.deleteAfterSentFiles.push(path);
         if (fileSize === 0) {
             throw new Error('文件异常，大小为0');
         }
         const thumbDir = path.replace(`${pathLib.sep}Ori${pathLib.sep}`, `${pathLib.sep}Thumb${pathLib.sep}`);
         fs.mkdirSync(pathLib.dirname(thumbDir), { recursive: true });
         const thumbPath = pathLib.join(pathLib.dirname(thumbDir), `${md5}_0.png`);
+        try {
+            videoInfo = await FFmpegService.getVideoInfo(filePath, thumbPath);
+        } catch {
+            fs.writeFileSync(thumbPath, Buffer.from(defaultVideoThumbB64, 'base64'));
+        }
         if (_diyThumbPath) {
             try {
                 await this.copyFile(_diyThumbPath, thumbPath);
             } catch (e) {
                 this.context.logger.logError('复制自定义缩略图失败', e);
             }
-        } else {
-            try {
-                videoInfo = await FFmpegService.getVideoInfo(filePath, thumbPath);
-                if (!fs.existsSync(thumbPath)) {
-                    this.context.logger.logError('获取视频缩略图失败', new Error('缩略图不存在'));
-                    throw new Error('获取视频缩略图失败');
-                }
-            } catch (e) {
-                this.context.logger.logError('获取视频信息失败', e);
-                fs.writeFileSync(thumbPath, Buffer.from(defaultVideoThumbB64, 'base64'));
-            }
         }
         context.deleteAfterSentFiles.push(thumbPath);
         const thumbSize = (await fsPromises.stat(thumbPath)).size;
@@ -231,7 +224,7 @@ export class NTQQFileApi {
             },
         };
     }
-    async createValidSendPttElement(_context: SendMessageContext, pttPath: string): Promise<SendPttElement> {
+    async createValidSendPttElement(pttPath: string): Promise<SendPttElement> {
 
         const { converted, path: silkPath, duration } = await encodeSilk(pttPath, this.core.NapCatTempPath, this.core.context.logger);
         if (!silkPath) {
@@ -308,18 +301,18 @@ export class NTQQFileApi {
                     element.elementType === ElementType.FILE
                 ) {
                     switch (element.elementType) {
-                        case ElementType.PIC:
+                    case ElementType.PIC:
                             element.picElement!.sourcePath = elementResults?.[elementIndex] ?? '';
-                            break;
+                        break;
-                        case ElementType.VIDEO:
+                    case ElementType.VIDEO:
                             element.videoElement!.filePath = elementResults?.[elementIndex] ?? '';
-                            break;
+                        break;
-                        case ElementType.PTT:
+                    case ElementType.PTT:
                             element.pttElement!.filePath = elementResults?.[elementIndex] ?? '';
-                            break;
+                        break;
-                        case ElementType.FILE:
+                    case ElementType.FILE:
                             element.fileElement!.filePath = elementResults?.[elementIndex] ?? '';
-                            break;
+                        break;
                     }
                     elementIndex++;
                 }

src/core/apis/group.ts

@@ -218,10 +218,6 @@ export class NTQQGroupApi {
         return this.context.session.getRichMediaService().deleteGroupFolder(groupCode, folderId);
     }
 
-    async transGroupFile(groupCode: string, fileId: string) {
-        return this.context.session.getRichMediaService().transGroupFile(groupCode, fileId);
-    }
-
     async addGroupEssence(groupCode: string, msgId: string) {
         const MsgData = await this.context.session.getMsgService().getMsgsIncludeSelf({
             chatType: 2,

src/core/apis/msg.ts

@@ -12,7 +12,7 @@ export class NTQQMsgApi {
         this.context = context;
         this.core = core;
     }
-
+    
     async clickInlineKeyboardButton(...params: Parameters<NodeIKernelMsgService['clickInlineKeyboardButton']>) {
         return this.context.session.getMsgService().clickInlineKeyboardButton(...params);
     }

src/core/apis/user.ts

@@ -90,30 +90,7 @@ export class NTQQUserApi {
             () => true,
             (profile) => profile.uid === uid,
         );
-        return profile;
+        const RetUser: User = {
-    }
-
-    async getUserDetailInfo(uid: string, no_cache: boolean = false): Promise<User> {
-        let profile = await solveAsyncProblem(async (uid) => this.fetchUserDetailInfo(uid, no_cache ? UserDetailSource.KSERVER : UserDetailSource.KDB), uid);
-        if (profile && profile.uin !== '0' && profile.commonExt) {
-            return {
-                ...profile.simpleInfo.status,
-                ...profile.simpleInfo.vasInfo,
-                ...profile.commonExt,
-                ...profile.simpleInfo.baseInfo,
-                ...profile.simpleInfo.coreInfo,
-                qqLevel: profile.commonExt?.qqLevel,
-                age: profile.simpleInfo.baseInfo.age,
-                pendantId: '',
-                nick: profile.simpleInfo.coreInfo.nick || '',
-            };
-        }
-        this.context.logger.logDebug('[NapCat] [Mark] getUserDetailInfo Mode1 Failed.');
-        profile = await this.fetchUserDetailInfo(uid, UserDetailSource.KSERVER);
-        if (profile && profile.uin === '0') {
-            profile.uin = await this.core.apis.UserApi.getUidByUinV2(uid) ?? '0';
-        }
-        return {
             ...profile.simpleInfo.status,
             ...profile.simpleInfo.vasInfo,
             ...profile.commonExt,
@@ -124,6 +101,33 @@ export class NTQQUserApi {
             pendantId: '',
             nick: profile.simpleInfo.coreInfo.nick || '',
         };
+        return RetUser;
+    }
+
+    async getUserDetailInfo(uid: string): Promise<User> {
+        let retUser = await solveAsyncProblem(async (uid) => this.fetchUserDetailInfo(uid, UserDetailSource.KDB), uid);
+        if (retUser && retUser.uin !== '0') {
+            return retUser;
+        }
+        this.context.logger.logDebug('[NapCat] [Mark] getUserDetailInfo Mode1 Failed.');
+        retUser = await this.fetchUserDetailInfo(uid, UserDetailSource.KSERVER);
+        if (retUser && retUser.uin === '0') {
+            retUser.uin = await this.core.apis.UserApi.getUidByUinV2(uid) ?? '0';
+        }
+        return retUser;
+    }
+
+    async getUserDetailInfoV2(uid: string): Promise<User> {
+        const fallback = new Fallback<User>((user) => FallbackUtil.boolchecker(user, user !== undefined && user.uin !== '0'))
+            .add(() => this.fetchUserDetailInfo(uid, UserDetailSource.KDB))
+            .add(() => this.fetchUserDetailInfo(uid, UserDetailSource.KSERVER));
+        const retUser = await fallback.run().then(async (user) => {
+            if (user && user.uin === '0') {
+                user.uin = await this.core.apis.UserApi.getUidByUinV2(uid) ?? '0';
+            }
+            return user;
+        });
+        return retUser;
     }
 
     async modifySelfProfile(param: ModifyProfileParams) {

src/core/external/appid.json

@@ -226,37 +226,5 @@
     "9.9.18-33139": {
         "appid": 537273874,
         "qua": "V1_WIN_NQ_9.9.18_33139_GW_B"
-    },
-    "9.9.18-33800": {
-        "appid": 537273974,
-        "qua": "V1_WIN_NQ_9.9.18_33800_GW_B"
-    },
-    "3.2.16-33800": {
-        "appid": 537274009,
-        "qua": "V1_LNX_NQ_3.2.16_33800_GW_B"
-    },
-    "9.9.19-34231": {
-        "appid": 537279209,
-        "qua": "V1_WIN_NQ_9.9.19_34231_GW_B"
-    },
-    "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"
-    },
-    "3.2.17-34362": {
-        "appid": 537279296,
-        "qua": "V1_LNX_NQ_3.2.17_34362_GW_B"
-    },
-    "9.9.19-34467": {
-        "appid": 537282256,
-        "qua": "V1_WIN_NQ_9.9.19_34467_GW_B"
-    },
-    "3.2.17-34467": {
-        "appid": 537282292,
-        "qua": "V1_LNX_NQ_3.2.17_34467_GW_B"
     }
 }

src/core/external/offset.json

@@ -302,37 +302,5 @@
     "3.2.16-33139-arm64": {
         "send": "7262BB0",
         "recv": "72664E0"
-    },
-    "9.9.18-33800-x64": {
-        "send": "39F5870",
-        "recv": "39FA070"
-    },
-    "3.2.16-33800-x64": {
-        "send": "A634F60",
-        "recv": "A638980"
-    },
-    "3.2.16-33800-arm64": {
-        "send": "7262BB0",
-        "recv": "72664E0"
-    },
-    "9.9.19-34231-x64": {
-        "send": "3BD73D0",
-        "recv": "3BDBBD0"
-    },
-    "3.2.17-34231-x64": {
-        "send": "AD787E0",
-        "recv": "AD7C200"
-    },
-    "3.2.17-34231-arm64": {
-        "send": "770CDC0",
-        "recv": "77106F0"
-    },
-    "9.9.19-34362-x64":{
-        "send": "3BD80D0",
-        "recv": "3BDC8D0"
-    },
-    "9.9.19-34467-x64": {
-        "send": "3BD8690",
-        "recv": "3BDCE90"
     }
 }

src/core/helper/rkey.ts

@@ -6,17 +6,6 @@ interface ServerRkeyData {
     private_rkey: string;
     expired_time: number;
 }
-interface OneBotApiRet {
-    status: string,
-    retcode: number,
-    data: ServerRkeyData,
-    message: string,
-    wording: string,
-}
-interface UrlFailureInfo {
-    count: number;
-    lastTimestamp: number;
-}
 
 export class RkeyManager {
     serverUrl: string[] = [];
@@ -26,8 +15,9 @@ export class RkeyManager {
         private_rkey: '',
         expired_time: 0,
     };
-    private urlFailures: Map<string, UrlFailureInfo> = new Map();
+    private failureCount: number = 0;
-    private readonly FAILURE_LIMIT: number = 4;
+    private lastFailureTimestamp: number = 0;
+    private readonly FAILURE_LIMIT: number = 8;
     private readonly ONE_DAY: number = 24 * 60 * 60 * 1000;
 
     constructor(serverUrl: string[], logger: LogWrapper) {
@@ -36,92 +26,50 @@ export class RkeyManager {
     }
 
     async getRkey() {
-        const availableUrls = this.getAvailableUrls();
+        const now = new Date().getTime();
-        if (availableUrls.length === 0) {
+        if (now - this.lastFailureTimestamp > this.ONE_DAY) {
-            this.logger.logError('[Rkey] 所有服务均已禁用, 图片使用FallBack机制');
+            this.failureCount = 0; // 重置失败计数器
-            throw new Error('获取rkey失败：所有服务URL均已被禁用');
+        }
+
+        if (this.failureCount >= this.FAILURE_LIMIT) {
+            this.logger.logError('[Rkey] 服务存在异常, 图片使用FallBack机制');
+            throw new Error('获取rkey失败次数过多，请稍后再试');
         }
 
         if (this.isExpired()) {
             try {
                 await this.refreshRkey();
             } catch (e) {
-                throw new Error(`${e}`);
+                throw new Error(`${e}`);//外抛
             }
         }
         return this.rkeyData;
     }
 
-    private getAvailableUrls(): string[] {
-        return this.serverUrl.filter(url => !this.isUrlDisabled(url));
-    }
-
-    private isUrlDisabled(url: string): boolean {
-        const failureInfo = this.urlFailures.get(url);
-        if (!failureInfo) return false;
-
-        const now = new Date().getTime();
-        // 如果已经过了一天，重置失败计数
-        if (now - failureInfo.lastTimestamp > this.ONE_DAY) {
-            failureInfo.count = 0;
-            this.urlFailures.set(url, failureInfo);
-            return false;
-        }
-
-        return failureInfo.count >= this.FAILURE_LIMIT;
-    }
-
-    private updateUrlFailure(url: string) {
-        const now = new Date().getTime();
-        const failureInfo = this.urlFailures.get(url) || { count: 0, lastTimestamp: 0 };
-
-        // 如果已经过了一天，重置失败计数
-        if (now - failureInfo.lastTimestamp > this.ONE_DAY) {
-            failureInfo.count = 1;
-        } else {
-            failureInfo.count++;
-        }
-
-        failureInfo.lastTimestamp = now;
-        this.urlFailures.set(url, failureInfo);
-
-        if (failureInfo.count >= this.FAILURE_LIMIT) {
-            this.logger.logError(`[Rkey] URL ${url} 已被禁用，失败次数达到 ${this.FAILURE_LIMIT} 次`);
-        }
-    }
-
     isExpired(): boolean {
         const now = new Date().getTime() / 1000;
         return now > this.rkeyData.expired_time;
     }
 
     async refreshRkey() {
-        const availableUrls = this.getAvailableUrls();
+        //刷新rkey
-
+        for (const url of this.serverUrl) {
-        if (availableUrls.length === 0) {
-            this.logger.logError('[Rkey] 所有服务均已禁用');
-            throw new Error('获取rkey失败：所有服务URL均已被禁用');
-        }
-
-        for (const url of availableUrls) {
             try {
-                let temp = await RequestUtil.HttpGetJson<ServerRkeyData>(url, 'GET');
+                const temp = await RequestUtil.HttpGetJson<ServerRkeyData>(url, 'GET');
-                if ('retcode' in temp) {
-                    // 支持Onebot Ret风格
-                    temp = (temp as unknown as OneBotApiRet).data;
-                }
                 this.rkeyData = {
                     group_rkey: temp.group_rkey.slice(6),
                     private_rkey: temp.private_rkey.slice(6),
                     expired_time: temp.expired_time
                 };
+                this.failureCount = 0;
                 return;
             } catch (e) {
                 this.logger.logError(`[Rkey] 异常服务 ${url} 异常 / `, e);
-                this.updateUrlFailure(url);
+                this.failureCount++;
-
+                this.lastFailureTimestamp = new Date().getTime();
-                if (url === availableUrls[availableUrls.length - 1]) {
+                //是否为最后一个url
-                    throw new Error(`获取rkey失败: ${e}`);
+                if (url === this.serverUrl[this.serverUrl.length - 1]) {
+                    throw new Error(`获取rkey失败: ${e}`);//外抛
                 }
             }
         }

src/core/packet/client/nativeClient.ts

@@ -38,12 +38,12 @@ export class NativePacketClient extends IPacketClient {
         return true;
     }
 
-    async init(_pid: number, recv: string, send: string): Promise<void> {
+    async init(pid: number, recv: string, send: string): Promise<void> {
         const platform = process.platform + '.' + process.arch;
         const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './moehoo/MoeHoo.' + platform + '.node');
         process.dlopen(this.MoeHooExport, moehoo_path, constants.dlopen.RTLD_LAZY);
-
+        
-        this.MoeHooExport.exports.InitHook?.(send, recv, (type: number, _uin: string, cmd: string, seq: number, hex_data: string) => {
+        this.MoeHooExport.exports.InitHook?.(send, recv, (type: number, uin: string, cmd: string, seq: number, hex_data: string) => {
             const trace_id = createHash('md5').update(Buffer.from(hex_data, 'hex')).digest('hex');
             if (type === 0 && this.cb.get(trace_id + 'recv')) {
                 //此时为send 提取seq

src/core/packet/client/wsClient.ts

@@ -0,0 +1,112 @@
+import { IPacketClient, RecvPacket } from '@/core/packet/client/baseClient';
+import { LogStack } from '@/core/packet/context/clientContext';
+import { NapCoreContext } from '@/core/packet/context/napCoreContext';
+import { PacketLogger } from '@/core/packet/context/loggerContext';
+
+export class WsPacketClient extends IPacketClient {
+    private websocket: WebSocket | null = null;
+    private reconnectAttempts: number = 0;
+    private readonly maxReconnectAttempts: number = 60; // 现在暂时不可配置
+    private readonly clientUrl: string;
+    private readonly clientUrlWrap: (url: string) => string = (url: string) => `ws://${url}/ws`;
+
+    private isInitialized: boolean = false;
+    private initPayload: { pid: number, recv: string, send: string } | null = null;
+
+    constructor(napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) {
+        super(napCore, logger, logStack);
+        this.clientUrl = this.napcore.config.packetServer
+            ? this.clientUrlWrap(this.napcore.config.packetServer)
+            : this.clientUrlWrap('127.0.0.1:8083');
+    }
+
+    check(): boolean {
+        if (!this.napcore.config.packetServer) {
+            this.logStack.pushLogWarn('wsPacketClient 未配置服务器地址');
+            return false;
+        }
+        return true;
+    }
+
+    async init(pid: number, recv: string, send: string): Promise<void> {
+        this.initPayload = { pid, recv, send };
+        await this.connectWithRetry();
+    }
+
+    sendCommandImpl(cmd: string, data: string, trace_id: string): void {
+        if (this.websocket && this.websocket.readyState === WebSocket.OPEN) {
+            this.websocket.send(JSON.stringify({
+                action: 'send',
+                cmd,
+                data,
+                trace_id
+            }));
+        } else {
+            this.logStack.pushLogWarn(`WebSocket 未连接，无法发送命令: ${cmd}`);
+        }
+    }
+
+    private async connectWithRetry(): Promise<void> {
+        while (this.reconnectAttempts < this.maxReconnectAttempts) {
+            try {
+                await this.connect();
+                return;
+            } catch {
+                this.reconnectAttempts++;
+                this.logStack.pushLogWarn(`第 ${this.reconnectAttempts}/${this.maxReconnectAttempts} 次尝试重连失败！`);
+                await this.delay(5000);
+            }
+        }
+        this.logStack.pushLogError(`wsPacketClient 在 ${this.clientUrl} 达到最大重连次数 (${this.maxReconnectAttempts})！`);
+        throw new Error(`无法连接到 WebSocket 服务器：${this.clientUrl}`);
+    }
+
+    private connect(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.websocket = new WebSocket(this.clientUrl);
+            this.websocket.onopen = () => {
+                this.available = true;
+                this.reconnectAttempts = 0;
+                this.logger.info(`wsPacketClient 已连接到 ${this.clientUrl}`);
+                if (!this.isInitialized && this.initPayload) {
+                    this.websocket!.send(JSON.stringify({
+                        action: 'init',
+                        ...this.initPayload
+                    }));
+                    this.isInitialized = true;
+                }
+                resolve();
+            };
+            this.websocket.onclose = () => {
+                this.available = false;
+                this.logger.warn('WebSocket 连接关闭，尝试重连...');
+                reject(new Error('WebSocket 连接关闭'));
+            };
+            this.websocket.onmessage = (ev: MessageEvent<any>) => this.handleMessage(ev).catch(err => {
+                this.logger.error(`处理消息时出错: ${err}`);
+            });
+            this.websocket.onerror = (event) => {
+                this.available = false;
+                this.logger.error(`WebSocket 出错: ${event}`);
+                this.websocket?.close();
+                reject(new Error(`WebSocket 出错: ${event}`));
+            };
+        });
+    }
+
+    private delay(ms: number): Promise<void> {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    private async handleMessage(message: MessageEvent): Promise<void> {
+        try {
+            const json: RecvPacket = JSON.parse(message.data.toString());
+            const trace_id_md5 = json.trace_id_md5;
+            const action = json?.type ?? 'init';
+            const event = this.cb.get(`${trace_id_md5}${action}`);
+            if (event) await event(json.data);
+        } catch (error) {
+            this.logger.error(`解析ws消息时出错: ${(error as Error).message}`);
+        }
+    }
+}

src/core/packet/context/clientContext.ts

@@ -1,5 +1,6 @@
 import { IPacketClient } from '@/core/packet/client/baseClient';
 import { NativePacketClient } from '@/core/packet/client/nativeClient';
+import { WsPacketClient } from '@/core/packet/client/wsClient';
 import { OidbPacket } from '@/core/packet/transformer/base';
 import { PacketLogger } from '@/core/packet/context/loggerContext';
 import { NapCoreContext } from '@/core/packet/context/napCoreContext';
@@ -9,7 +10,8 @@ type clientPriorityType = {
 }
 
 const clientPriority: clientPriorityType = {
-    10: (napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) => new NativePacketClient(napCore, logger, logStack)
+    10: (napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) => new NativePacketClient(napCore, logger, logStack),
+    1: (napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) => new WsPacketClient(napCore, logger, logStack),
 };
 
 export class LogStack {
@@ -86,6 +88,10 @@ export class PacketClientContext {
             this.logger.info('使用指定的 NativePacketClient 作为后端');
             client = new NativePacketClient(this.napCore, this.logger, this.logStack);
             break;
+        case 'frida':
+            this.logger.info('[Core] [Packet] 使用指定的 FridaPacketClient 作为后端');
+            client = new WsPacketClient(this.napCore, this.logger, this.logStack);
+            break;
         case 'auto':
         case undefined:
             client = this.judgeClient();

src/core/packet/context/operationContext.ts

@@ -68,8 +68,8 @@ export class PacketOperationContext {
         }
     }
 
-    async SetGroupSpecialTitle(groupUin: number, uid: string, title: string) {
+    async SetGroupSpecialTitle(groupUin: number, uid: string, tittle: string) {
-        const req = trans.SetSpecialTitle.build(groupUin, uid, title);
+        const req = trans.SetSpecialTitle.build(groupUin, uid, tittle);
         await this.context.client.sendOidbPacket(req);
     }
 
@@ -154,20 +154,6 @@ export class PacketOperationContext {
         return res.result.resId;
     }
 
-    async MoveGroupFile(groupUin: number, fileUUID: string, currentParentDirectory: string, targetParentDirectory: string) {
-        const req = trans.MoveGroupFile.build(groupUin, fileUUID, currentParentDirectory, targetParentDirectory);
-        const resp = await this.context.client.sendOidbPacket(req, true);
-        const res = trans.MoveGroupFile.parse(resp);
-        return res.move.retCode;
-    }
-
-    async RenameGroupFile(groupUin: number, fileUUID: string, currentParentDirectory: string, newName: string) {
-        const req = trans.RenameGroupFile.build(groupUin, fileUUID, currentParentDirectory, newName);
-        const resp = await this.context.client.sendOidbPacket(req, true);
-        const res = trans.RenameGroupFile.parse(resp);
-        return res.rename.retCode;
-    }
-
     async GetGroupFileUrl(groupUin: number, fileUUID: string) {
         const req = trans.DownloadGroupFile.build(groupUin, fileUUID);
         const resp = await this.context.client.sendOidbPacket(req, true);

src/core/packet/transformer/action/MoveGroupFile.ts

@@ -1,35 +0,0 @@
-import * as proto from '@/core/packet/transformer/proto';
-import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketTransformer } from '@/core/packet/transformer/base';
-import OidbBase from '@/core/packet/transformer/oidb/oidbBase';
-
-class MoveGroupFile extends PacketTransformer<typeof proto.OidbSvcTrpcTcp0x6D6Response> {
-    constructor() {
-        super();
-    }
-
-    build(groupUin: number, fileUUID: string, currentParentDirectory: string, targetParentDirectory: string): OidbPacket {
-        const body = new NapProtoMsg(proto.OidbSvcTrpcTcp0x6D6).encode({
-            move: {
-                groupUin: groupUin,
-                appId: 5,
-                busId: 102,
-                fileId: fileUUID,
-                parentDirectory: currentParentDirectory,
-                targetDirectory: targetParentDirectory,
-            }
-        });
-        return OidbBase.build(0x6D6, 5, body, true, false);
-    }
-
-    parse(data: Buffer) {
-        const oidbBody = OidbBase.parse(data).body;
-        const res = new NapProtoMsg(proto.OidbSvcTrpcTcp0x6D6Response).decode(oidbBody);
-        if (res.move.retCode !== 0) {
-            throw new Error(`sendGroupFileMoveReq error: ${res.move.clientWording} (code=${res.move.retCode})`);
-        }
-        return res;
-    }
-}
-
-export default new MoveGroupFile();

src/core/packet/transformer/action/RenameGroupFile.ts

@@ -1,34 +0,0 @@
-import * as proto from '@/core/packet/transformer/proto';
-import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketTransformer } from '@/core/packet/transformer/base';
-import OidbBase from '@/core/packet/transformer/oidb/oidbBase';
-
-class RenameGroupFile extends PacketTransformer<typeof proto.OidbSvcTrpcTcp0x6D6Response> {
-    constructor() {
-        super();
-    }
-
-    build(groupUin: number, fileUUID: string, currentParentDirectory: string, newName: string): OidbPacket {
-        const body = new NapProtoMsg(proto.OidbSvcTrpcTcp0x6D6).encode({
-            rename: {
-                groupUin: groupUin,
-                busId: 102,
-                fileId: fileUUID,
-                parentFolder: currentParentDirectory,
-                newFileName: newName,
-            }
-        });
-        return OidbBase.build(0x6D6, 4, body, true, false);
-    }
-
-    parse(data: Buffer) {
-        const oidbBody = OidbBase.parse(data).body;
-        const res = new NapProtoMsg(proto.OidbSvcTrpcTcp0x6D6Response).decode(oidbBody);
-        if (res.rename.retCode !== 0) {
-            throw new Error(`sendGroupFileRenameReq error: ${res.rename.clientWording} (code=${res.rename.retCode})`);
-        }
-        return res;
-    }
-}
-
-export default new RenameGroupFile();

src/core/packet/transformer/action/SetSpecialTitle.ts

@@ -8,14 +8,14 @@ class SetSpecialTitle extends PacketTransformer<typeof proto.OidbSvcTrpcTcpBase>
         super();
     }
 
-    build(groupCode: number, uid: string, title: string): OidbPacket {
+    build(groupCode: number, uid: string, tittle: string): OidbPacket {
         const oidb_0x8FC_2 = new NapProtoMsg(proto.OidbSvcTrpcTcp0X8FC_2).encode({
             groupUin: +groupCode,
             body: {
                 targetUid: uid,
-                specialTitle: title,
+                specialTitle: tittle,
                 expiredTime: -1,
-                uinName: title
+                uinName: tittle
             }
         });
         return OidbBase.build(0x8FC, 2, oidb_0x8FC_2, false, false);

src/core/packet/transformer/action/index.ts

@@ -6,5 +6,3 @@ export { default as GetStrangerInfo } from './GetStrangerInfo';
 export { default as SendPoke } from './SendPoke';
 export { default as SetSpecialTitle } from './SetSpecialTitle';
 export { default as ImageOCR } from './ImageOCR';
-export { default as MoveGroupFile } from './MoveGroupFile';
-export { default as RenameGroupFile } from './RenameGroupFile';

src/core/services/NodeIKernelBuddyService.ts

@@ -16,7 +16,7 @@ export interface NodeIKernelBuddyService {
 
     getBuddyListFromCache(reqType: BuddyListReqType): Promise<Array<
         {
-            categoryId: number,//9999为特别关心
+            categoryId: number,//9999应该跳过 那是兜底数据吧
             categorySortId: number,//排序方式
             categroyName: string,//分类名
             categroyMbCount: number,//不懂

src/core/services/NodeIKernelProfileService.ts

@@ -1,5 +1,5 @@
 import { AnyCnameRecord } from 'node:dns';
-import { BizKey, ModifyProfileParams, NodeIKernelProfileListener, ProfileBizType, SimpleInfo, UserDetailInfoByUin, UserDetailInfoListenerArg, UserDetailSource } from '@/core';
+import { BizKey, ModifyProfileParams, NodeIKernelProfileListener, ProfileBizType, SimpleInfo, UserDetailInfoByUin, UserDetailSource } from '@/core';
 import { GeneralCallResult } from '@/core/services/common';
 
 export interface NodeIKernelProfileService {
@@ -15,13 +15,7 @@ export interface NodeIKernelProfileService {
 
     getCoreAndBaseInfo(callfrom: string, uids: string[]): Promise<Map<string, SimpleInfo>>;
 
-    fetchUserDetailInfo(trace: string, uids: string[], source: UserDetailSource, bizType: ProfileBizType[]): Promise<GeneralCallResult &
+    fetchUserDetailInfo(trace: string, uids: string[], source: UserDetailSource, bizType: ProfileBizType[]): Promise<GeneralCallResult>;
-    {
-        source: UserDetailSource,
-        // uid -> detail
-        detail: Map<string, UserDetailInfoListenerArg>,
-    }
-    >;
 
     addKernelProfileListener(listener: NodeIKernelProfileListener): number;
 

src/core/services/NodeIKernelRichMediaService.ts

@@ -198,29 +198,9 @@ export interface NodeIKernelRichMediaService {
 
     renameGroupFile(arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown, arg5: unknown): unknown;
 
-    moveGroupFile(groupCode: string, busId: Array<number>, fileList: Array<string>, currentParentDirectory: string, targetParentDirectory: string): Promise<GeneralCallResult & {
+    moveGroupFile(arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown, arg5: unknown): unknown;
-        moveGroupFileResult: {
-            result: {
-                retCode: number,
-                retMsg: symbol,
-                clientWording: string
-            },
-            successFileIdList: Array<string>,
-            failFileIdList: Array<string>
-        }
-    }>;
 
-    transGroupFile(groupCode: string, fileId: string): Promise<GeneralCallResult & {
+    transGroupFile(arg1: unknown, arg2: unknown): unknown;
-        transGroupFileResult: {
-            result: {
-                retCode: number
-                retMsg: string
-                clientWording: string
-            }
-            saveBusId: number
-            saveFilePath: string
-        }
-    }>;
 
     searchGroupFile(
         keywords: Array<string>,

src/core/types/user.ts

@@ -207,7 +207,6 @@ interface PhotoWall {
 
 // 简单信息
 export interface SimpleInfo {
-    qqLevel?: QQLevel;//临时添加
     uid?: string;
     uin?: string;
     coreInfo: CoreInfo;

src/core/types/webapi.ts

@@ -115,7 +115,7 @@ export interface GroupEssenceMsg {
     add_digest_uin: string;
     add_digest_nick: string;
     add_digest_time: number;
-    msg_content: { msg_type: number, text?: string, image_url?: string }[];
+    msg_content: unknown[];
     can_be_removed: true;
 }
 

src/framework/napcat.ts

@@ -7,15 +7,11 @@ import { SelfInfo } from '@/core/types';
 import { NodeIKernelLoginListener } from '@/core/listeners';
 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() {
-    const WebUiConfigData = (await WebUiConfig.GetWebUIConfig());
+    return 'http://127.0.0.1:' + 6099 + '/webui/?token=napcat';
-    return 'http://127.0.0.1:' + webUiRuntimePort + '/webui/?token=' + WebUiConfigData.token;
 }
 
 export async function NCoreInitFramework(
@@ -38,15 +34,6 @@ export async function NCoreInitFramework(
     const logger = new LogWrapper(pathWrapper.logsPath);
     const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
     const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVesion());
-    if (!process.env['NAPCAT_DISABLE_FFMPEG_DOWNLOAD']) {
-        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();
@@ -69,8 +56,6 @@ export async function NCoreInitFramework(
     const loaderObject = new NapCatFramework(wrapper, session, logger, loginService, selfInfo, basicInfoWrapper, pathWrapper);
     await loaderObject.core.initCore();
 
-    //启动WebUi
-    InitWebUi(logger, pathWrapper).then().catch(e => logger.logError(e));
     //初始化LLNC的Onebot实现
     await new NapCatOneBot11Adapter(loaderObject.core, loaderObject.context, pathWrapper).InitOneBot();
 }

src/onebot/action/OneBotAction.ts

@@ -3,7 +3,6 @@ import Ajv, { ErrorObject, ValidateFunction } from 'ajv';
 import { NapCatCore } from '@/core';
 import { NapCatOneBot11Adapter, OB11Return } from '@/onebot';
 import { NetworkAdapterConfig } from '../config/config';
-import { TSchema } from '@sinclair/typebox';
 
 export class OB11Response {
     private static createResponse<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null): OB11Return<T> {
@@ -34,7 +33,7 @@ export abstract class OneBotAction<PayloadType, ReturnDataType> {
     actionName: typeof ActionName[keyof typeof ActionName] = ActionName.Unknown;
     core: NapCatCore;
     private validate?: ValidateFunction<unknown> = undefined;
-    payloadSchema?: TSchema = undefined;
+    payloadSchema?: unknown = undefined;
     obContext: NapCatOneBot11Adapter;
 
     constructor(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
@@ -44,7 +43,7 @@ export abstract class OneBotAction<PayloadType, ReturnDataType> {
 
     protected async check(payload: PayloadType): Promise<BaseCheckResult> {
         if (this.payloadSchema) {
-            this.validate = new Ajv({ allowUnionTypes: true, useDefaults: true, coerceTypes: true }).compile(this.payloadSchema);
+            this.validate = new Ajv({ allowUnionTypes: true, useDefaults: true }).compile(this.payloadSchema);
         }
         if (this.validate && !this.validate(payload)) {
             const errors = this.validate.errors as ErrorObject[];

src/onebot/action/extends/MoveGroupFile.ts

@@ -1,33 +0,0 @@
-import { ActionName } from '@/onebot/action/router';
-import { FileNapCatOneBotUUID } from '@/common/file-uuid';
-import { GetPacketStatusDepends } from '@/onebot/action/packet/GetPacketStatus';
-import { Static, Type } from '@sinclair/typebox';
-
-const SchemaData = Type.Object({
-    group_id: Type.Union([Type.Number(), Type.String()]),
-    file_id: Type.String(),
-    current_parent_directory: Type.String(),
-    target_parent_directory: Type.String(),
-});
-
-type Payload = Static<typeof SchemaData>;
-
-interface MoveGroupFileResponse {
-    ok: boolean;
-}
-
-export class MoveGroupFile extends GetPacketStatusDepends<Payload, MoveGroupFileResponse> {
-    override actionName = ActionName.MoveGroupFile;
-    override payloadSchema = SchemaData;
-
-    async _handle(payload: Payload) {
-        const contextMsgFile = FileNapCatOneBotUUID.decode(payload.file_id) || FileNapCatOneBotUUID.decodeModelId(payload.file_id);
-        if (contextMsgFile?.fileUUID) {
-            await this.core.apis.PacketApi.pkt.operation.MoveGroupFile(+payload.group_id, contextMsgFile.fileUUID, payload.current_parent_directory, payload.target_parent_directory);
-            return {
-                ok: true,
-            };
-        }
-        throw new Error('real fileUUID not found!');
-    }
-}

src/onebot/action/extends/RenameGroupFile.ts

@@ -1,33 +0,0 @@
-import { ActionName } from '@/onebot/action/router';
-import { FileNapCatOneBotUUID } from '@/common/file-uuid';
-import { GetPacketStatusDepends } from '@/onebot/action/packet/GetPacketStatus';
-import { Static, Type } from '@sinclair/typebox';
-
-const SchemaData = Type.Object({
-    group_id: Type.Union([Type.Number(), Type.String()]),
-    file_id: Type.String(),
-    current_parent_directory: Type.String(),
-    new_name: Type.String(),
-});
-
-type Payload = Static<typeof SchemaData>;
-
-interface RenameGroupFileResponse {
-    ok: boolean;
-}
-
-export class RenameGroupFile extends GetPacketStatusDepends<Payload, RenameGroupFileResponse> {
-    override actionName = ActionName.RenameGroupFile;
-    override payloadSchema = SchemaData;
-
-    async _handle(payload: Payload) {
-        const contextMsgFile = FileNapCatOneBotUUID.decode(payload.file_id) || FileNapCatOneBotUUID.decodeModelId(payload.file_id);
-        if (contextMsgFile?.fileUUID) {
-            await this.core.apis.PacketApi.pkt.operation.RenameGroupFile(+payload.group_id, contextMsgFile.fileUUID, payload.current_parent_directory, payload.new_name);
-            return {
-                ok: true,
-            };
-        }
-        throw new Error('real fileUUID not found!');
-    }
-}

src/onebot/action/extends/SetSpecialTittle.ts

@@ -10,8 +10,8 @@ const SchemaData = Type.Object({
 
 type Payload = Static<typeof SchemaData>;
 
-export class SetSpecialTitle extends GetPacketStatusDepends<Payload, void> {
+export class SetSpecialTittle extends GetPacketStatusDepends<Payload, void> {
-    override actionName = ActionName.SetSpecialTitle;
+    override actionName = ActionName.SetSpecialTittle;
     override payloadSchema = SchemaData;
 
     async _handle(payload: Payload) {

src/onebot/action/extends/TransGroupFile.ts

@@ -1,34 +0,0 @@
-import { ActionName } from '@/onebot/action/router';
-import { FileNapCatOneBotUUID } from '@/common/file-uuid';
-import { GetPacketStatusDepends } from '@/onebot/action/packet/GetPacketStatus';
-import { Static, Type } from '@sinclair/typebox';
-
-const SchemaData = Type.Object({
-    group_id: Type.Union([Type.Number(), Type.String()]),
-    file_id: Type.String(),
-});
-
-type Payload = Static<typeof SchemaData>;
-
-interface TransGroupFileResponse {
-    ok: boolean;
-}
-
-export class TransGroupFile extends GetPacketStatusDepends<Payload, TransGroupFileResponse> {
-    override actionName = ActionName.TransGroupFile;
-    override payloadSchema = SchemaData;
-
-    async _handle(payload: Payload) {
-        const contextMsgFile = FileNapCatOneBotUUID.decode(payload.file_id) || FileNapCatOneBotUUID.decodeModelId(payload.file_id);
-        if (contextMsgFile?.fileUUID) {
-            const result = await this.core.apis.GroupApi.transGroupFile(payload.group_id.toString(), contextMsgFile.fileUUID);
-            if (result.transGroupFileResult.result.retCode === 0) {
-                return {
-                    ok: true
-                };
-            }
-            throw new Error(result.transGroupFileResult.result.retMsg);
-        }
-        throw new Error('real fileUUID not found!');
-    }
-}

src/onebot/action/go-cqhttp/GetForwardMsg.ts

@@ -4,14 +4,14 @@ import { ActionName } from '@/onebot/action/router';
 import { MessageUnique } from '@/common/message-unique';
 import { Static, Type } from '@sinclair/typebox';
 import { ChatType, ElementType, MsgSourceType, NTMsgType, RawMessage } from '@/core';
-import { isNumeric } from '@/common/helper';
 
 const SchemaData = Type.Object({
-    message_id: Type.Optional(Type.String()),
+    message_id: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    id: Type.Optional(Type.String()),
+    id: Type.Optional(Type.Union([Type.Number(), Type.String()])),
 });
 
 type Payload = Static<typeof SchemaData>;
+
 export class GoCQHTTPGetForwardMsgAction extends OneBotAction<Payload, {
     messages: OB11Message[] | undefined;
 }> {
@@ -53,21 +53,19 @@ export class GoCQHTTPGetForwardMsgAction extends OneBotAction<Payload, {
     }
 
     async _handle(payload: Payload) {
-        // 1. 检查消息ID是否存在
         const msgId = payload.message_id || payload.id;
         if (!msgId) {
             throw new Error('message_id is required');
         }
 
-        // 2. 定义辅助函数 - 创建伪转发消息对象
+        const fakeForwardMsg = (res_id: string) => {
-        const createFakeForwardMsg = (resId: string): RawMessage => {
             return {
                 chatType: ChatType.KCHATTYPEGROUP,
                 elements: [{
                     elementType: ElementType.MULTIFORWARD,
                     elementId: '',
                     multiForwardMsgElement: {
-                        resId: resId,
+                        resId: res_id,
                         fileName: '',
                         xmlContent: '',
                     }
@@ -98,9 +96,8 @@ export class GoCQHTTPGetForwardMsgAction extends OneBotAction<Payload, {
             } as RawMessage;
         };
 
-        // 3. 定义协议回退逻辑函数
+        const protocolFallbackLogic = async (res_id: string) => {
-        const protocolFallbackLogic = async (resId: string) => {
+            const ob = (await this.obContext.apis.MsgApi.parseMessageV2(fakeForwardMsg(res_id)))?.arrayMsg;
-            const ob = (await this.obContext.apis.MsgApi.parseMessageV2(createFakeForwardMsg(resId)))?.arrayMsg;
             if (ob) {
                 return {
                     messages: (ob?.message?.[0] as OB11MessageForward)?.data?.content
@@ -108,37 +105,31 @@ export class GoCQHTTPGetForwardMsgAction extends OneBotAction<Payload, {
             }
             throw new Error('protocolFallbackLogic: 找不到相关的聊天记录');
         };
-        // 4. 尝试通过正常渠道获取消息
+
-        // 如果是数字ID，优先使用getMsgsByMsgId获取
-        if (!isNumeric(msgId)) {
-            let ret = await protocolFallbackLogic(msgId);
-            if (ret.messages) {
-                return ret;
-            }
-            throw new Error('ResId无效: 找不到相关的聊天记录');
-        }
         const rootMsgId = MessageUnique.getShortIdByMsgId(msgId.toString());
         const rootMsg = MessageUnique.getMsgIdAndPeerByShortId(rootMsgId ?? +msgId);
-
+        if (!rootMsg) {
-        if (rootMsg) {
+            return await protocolFallbackLogic(msgId.toString());
-            // 5. 获取消息内容
-            const data = await this.core.apis.MsgApi.getMsgsByMsgId(rootMsg.Peer, [rootMsg.MsgId]);
-
-            if (data && data.result === 0 && data.msgList.length > 0) {
-                const singleMsg = data.msgList[0];
-                if (!singleMsg) {
-                    throw new Error('消息不存在或已过期');
-                }
-                // 6. 解析消息内容
-                const resMsg = (await this.obContext.apis.MsgApi.parseMessageV2(singleMsg))?.arrayMsg;
-
-                const forwardContent = (resMsg?.message?.[0] as OB11MessageForward)?.data?.content;
-                if (forwardContent) {
-                    return { messages: forwardContent };
-                }
-            }
         }
-        // 说明消息已过期或者为内层消息 NapCat 一次返回不处理内层消息
+        const data = await this.core.apis.MsgApi.getMsgsByMsgId(rootMsg.Peer, [rootMsg.MsgId]);
-        throw new Error('消息已过期或者为内层消息，无法获取转发消息');
+
+        if (!data || data.result !== 0) {
+            return await protocolFallbackLogic(msgId.toString());
+        }
+
+        const singleMsg = data.msgList[0];
+        if (!singleMsg) {
+            return await protocolFallbackLogic(msgId.toString());
+        }
+        const resMsg = (await this.obContext.apis.MsgApi.parseMessageV2(singleMsg))?.arrayMsg;//强制array 以便处理
+        if (!(resMsg?.message?.[0] as OB11MessageForward)?.data?.content) {
+            return await protocolFallbackLogic(msgId.toString());
+        }
+        return {
+            messages: (resMsg?.message?.[0] as OB11MessageForward)?.data?.content
+        };
+        //}
+
+        // return { message: resMsg };
     }
 }

src/onebot/action/go-cqhttp/GetFriendMsgHistory.ts

@@ -11,10 +11,10 @@ interface Response {
     messages: OB11Message[];
 }
 const SchemaData = Type.Object({
-    user_id: Type.String(),
+    user_id: Type.Union([Type.Number(), Type.String()]),
-    message_seq: Type.Optional(Type.String()),
+    message_seq: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    count: Type.Number({ default: 20 }),
+    count: Type.Union([Type.Number(), Type.String()], { default: 20 }),
-    reverseOrder: Type.Boolean({ default: false })
+    reverseOrder: Type.Optional(Type.Union([Type.Boolean(), Type.String()]))
 });
 
 
@@ -27,14 +27,18 @@ export default class GetFriendMsgHistory extends OneBotAction<Payload, Response>
     async _handle(payload: Payload, _adapter: string, config: NetworkAdapterConfig): Promise<Response> {
         //处理参数
         const uid = await this.core.apis.UserApi.getUidByUinV2(payload.user_id.toString());
+
+        const isReverseOrder = typeof payload.reverseOrder === 'string' ? payload.reverseOrder === 'true' : !!payload.reverseOrder;
         if (!uid) throw new Error(`记录${payload.user_id}不存在`);
         const friend = await this.core.apis.FriendApi.isBuddy(uid);
         const peer = { chatType: friend ? ChatType.KCHATTYPEC2C : ChatType.KCHATTYPETEMPC2CFROMGROUP, peerUid: uid };
         const hasMessageSeq = !payload.message_seq ? !!payload.message_seq : !(payload.message_seq?.toString() === '' || payload.message_seq?.toString() === '0');
         const startMsgId = hasMessageSeq ? (MessageUnique.getMsgIdAndPeerByShortId(+payload.message_seq!)?.MsgId ?? payload.message_seq!.toString()) : '0';
         const msgList = hasMessageSeq ?
-            (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count, payload.reverseOrder)).msgList : (await this.core.apis.MsgApi.getAioFirstViewLatestMsgs(peer, +payload.count)).msgList;
+            (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count)).msgList : (await this.core.apis.MsgApi.getAioFirstViewLatestMsgs(peer, +payload.count)).msgList;
         if (msgList.length === 0) throw new Error(`消息${payload.message_seq}不存在`);
+        //翻转消息
+        if (isReverseOrder) msgList.reverse();
         //转换序号
         await Promise.all(msgList.map(async msg => {
             msg.id = MessageUnique.createUniqueMsgId({ guildId: '', chatType: msg.chatType, peerUid: msg.peerUid }, msg.msgId);

src/onebot/action/go-cqhttp/GetGroupMsgHistory.ts

@@ -11,10 +11,10 @@ interface Response {
 }
 
 const SchemaData = Type.Object({
-    group_id: Type.String(),
+    group_id: Type.Union([Type.Number(), Type.String()]),
-    message_seq: Type.Optional(Type.String()),
+    message_seq: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-    count: Type.Number({ default: 20 }),
+    count: Type.Union([Type.Number(), Type.String()], { default: 20 }),
-    reverseOrder: Type.Boolean({ default: false })
+    reverseOrder: Type.Optional(Type.Union([Type.Boolean(), Type.String()]))
 });
 
 
@@ -26,13 +26,17 @@ export default class GoCQHTTPGetGroupMsgHistory extends OneBotAction<Payload, Re
     override payloadSchema = SchemaData;
 
     async _handle(payload: Payload, _adapter: string, config: NetworkAdapterConfig): Promise<Response> {
+        //处理参数
+        const isReverseOrder = typeof payload.reverseOrder === 'string' ? payload.reverseOrder === 'true' : !!payload.reverseOrder;
         const peer: Peer = { chatType: ChatType.KCHATTYPEGROUP, peerUid: payload.group_id.toString() };
         const hasMessageSeq = !payload.message_seq ? !!payload.message_seq : !(payload.message_seq?.toString() === '' || payload.message_seq?.toString() === '0');
         //拉取消息
         const startMsgId = hasMessageSeq ? (MessageUnique.getMsgIdAndPeerByShortId(+payload.message_seq!)?.MsgId ?? payload.message_seq!.toString()) : '0';
         const msgList = hasMessageSeq ?
-            (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count, payload.reverseOrder)).msgList : (await this.core.apis.MsgApi.getAioFirstViewLatestMsgs(peer, +payload.count)).msgList;
+            (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count)).msgList : (await this.core.apis.MsgApi.getAioFirstViewLatestMsgs(peer, +payload.count)).msgList;
         if (msgList.length === 0) throw new Error(`消息${payload.message_seq}不存在`);
+        //翻转消息
+        if (isReverseOrder) msgList.reverse();
         //转换序号
         await Promise.all(msgList.map(async msg => {
             msg.id = MessageUnique.createUniqueMsgId({ guildId: '', chatType: msg.chatType, peerUid: msg.peerUid }, msg.msgId);

src/onebot/action/go-cqhttp/GetStrangerInfo.ts

@@ -7,7 +7,6 @@ import { Static, Type } from '@sinclair/typebox';
 
 const SchemaData = Type.Object({
     user_id: Type.Union([Type.Number(), Type.String()]),
-    no_cache: Type.Union([Type.Boolean(), Type.String()], { default: false }),
 });
 
 type Payload = Static<typeof SchemaData>;
@@ -17,11 +16,10 @@ export default class GoCQHTTPGetStrangerInfo extends OneBotAction<Payload, OB11U
     override payloadSchema = SchemaData;
     async _handle(payload: Payload) {
         const user_id = payload.user_id.toString();
-        const isNocache = typeof payload.no_cache === 'string' ? payload.no_cache === 'true' : !!payload.no_cache;
         const extendData = await this.core.apis.UserApi.getUserDetailInfoByUin(user_id);
         let uid = (await this.core.apis.UserApi.getUidByUinV2(user_id));
         if (!uid) uid = extendData.detail.uid;
-        const info = (await this.core.apis.UserApi.getUserDetailInfo(uid, isNocache));
+        const info = (await this.core.apis.UserApi.getUserDetailInfo(uid));
         return {
             ...extendData.detail.simpleInfo.coreInfo,
             ...extendData.detail.commonExt ?? {},

src/onebot/action/group/GetGroupInfo.ts

@@ -20,7 +20,6 @@ class GetGroupInfo extends OneBotAction<Payload, OB11Group> {
             const data = await this.core.apis.GroupApi.fetchGroupDetail(payload.group_id.toString());
             return {
                 ...data,
-                group_all_shut: data.shutUpAllTimestamp > 0 ? -1 : 0,
                 group_remark: '',
                 group_id: +payload.group_id,
                 group_name: data.groupName,

src/onebot/action/group/GetGroupMemberInfo.ts

@@ -32,7 +32,7 @@ class GetGroupMemberInfo extends OneBotAction<Payload, OB11GroupMember> {
 
         const [member, info] = await Promise.all([
             this.core.apis.GroupApi.getGroupMemberEx(payload.group_id.toString(), uid, isNocache),
-            this.core.apis.UserApi.getUserDetailInfo(uid, isNocache),
+            this.core.apis.UserApi.getUserDetailInfo(uid),
         ]);
 
         if (!member || !groupMember) throw new Error(`群(${payload.group_id})成员${payload.user_id}不存在`);

src/onebot/action/index.ts

@@ -81,7 +81,7 @@ import { GetGroupSystemMsg } from './system/GetSystemMsg';
 import { GroupPoke } from './group/GroupPoke';
 import { GetUserStatus } from './extends/GetUserStatus';
 import { GetRkey } from './extends/GetRkey';
-import { SetSpecialTitle } from './extends/SetSpecialTitle';
+import { SetSpecialTittle } from './extends/SetSpecialTittle';
 import { GetGroupShutList } from './group/GetGroupShutList';
 import { GetGroupMemberList } from './group/GetGroupMemberList';
 import { GetGroupFileUrl } from '@/onebot/action/file/GetGroupFileUrl';
@@ -109,18 +109,10 @@ import { ClickInlineKeyboardButton } from './extends/ClickInlineKeyboardButton';
 import { GetPrivateFileUrl } from './file/GetPrivateFileUrl';
 import { GetUnidirectionalFriendList } from './extends/GetUnidirectionalFriendList';
 import SetGroupRemark from './extends/SetGroupRemark';
-import { MoveGroupFile } from './extends/MoveGroupFile';
-import { TransGroupFile } from './extends/TransGroupFile';
-import { RenameGroupFile } from './extends/RenameGroupFile';
-import { GetRkeyServer } from './packet/GetRkeyServer';
-import { GetRkeyEx } from './packet/GetRkeyEx';
-import { CleanCache } from './system/CleanCache';
 
 export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
 
     const actionHandlers = [
-        new GetRkeyEx(obContext, core),
-        new GetRkeyServer(obContext, core),
         new SetGroupRemark(obContext, core),
         new GetGroupInfoEx(obContext, core),
         new FetchEmojiLike(obContext, core),
@@ -140,9 +132,6 @@ export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCo
         new SetGroupSign(obContext, core),
         new SendGroupSign(obContext, core),
         new GetClientkey(obContext, core),
-        new MoveGroupFile(obContext, core),
-        new RenameGroupFile(obContext, core),
-        new TransGroupFile(obContext, core),
         // onebot11
         new SendLike(obContext, core),
         new GetMsg(obContext, core),
@@ -226,7 +215,7 @@ export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCo
         new FriendPoke(obContext, core),
         new GetUserStatus(obContext, core),
         new GetRkey(obContext, core),
-        new SetSpecialTitle(obContext, core),
+        new SetSpecialTittle(obContext, core),
         new SetDiyOnlineStatus(obContext, core),
         // new UploadForwardMsg(obContext, core),
         new GetGroupShutList(obContext, core),
@@ -242,7 +231,6 @@ export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCo
         new ClickInlineKeyboardButton(obContext, core),
         new GetPrivateFileUrl(obContext, core),
         new GetUnidirectionalFriendList(obContext, core),
-        new CleanCache(obContext, core),
     ];
 
     type HandlerUnion = typeof actionHandlers[number];

src/onebot/action/msg/SendMsg.ts

@@ -1,7 +1,6 @@
 import {
     OB11MessageData,
     OB11MessageDataType,
-    OB11MessageForward,
     OB11MessageMixType,
     OB11MessageNode,
     OB11PostContext,
@@ -13,7 +12,7 @@ import { MessageUnique } from '@/common/message-unique';
 import { ChatType, ElementType, NapCatCore, Peer, RawMessage, SendArkElement, SendMessageElement } from '@/core';
 import { OneBotAction } from '@/onebot/action/OneBotAction';
 import { ForwardMsgBuilder } from '@/common/forward-msg-builder';
-import { isNumeric, stringifyWithBigInt } from '@/common/helper';
+import { stringifyWithBigInt } from '@/common/helper';
 import { PacketMsg } from '@/core/packet/message/message';
 import { rawMsgWithSendMsg } from '@/core/packet/message/converter';
 
@@ -39,7 +38,7 @@ export function normalize(message: OB11MessageMixType, autoEscape = false): OB11
 
 export async function createContext(core: NapCatCore, payload: OB11PostContext | undefined, contextMode: ContextMode = ContextMode.Normal): Promise<Peer> {
     if (!payload) {
-        throw new Error('请传递请求内容');
+        throw new Error('请指定 group_id 或 user_id');
     }
     if ((contextMode === ContextMode.Group || contextMode === ContextMode.Normal) && payload.group_id) {
         return {
@@ -49,16 +48,7 @@ export async function createContext(core: NapCatCore, payload: OB11PostContext |
     }
     if ((contextMode === ContextMode.Private || contextMode === ContextMode.Normal) && payload.user_id) {
         const Uid = await core.apis.UserApi.getUidByUinV2(payload.user_id.toString());
-        if (!Uid) {
+        if (!Uid) throw new Error('无法获取用户信息');
-            if (payload.group_id) {
-                return {
-                    chatType: ChatType.KCHATTYPEGROUP,
-                    peerUid: payload.group_id.toString(),
-                    guildId: ''
-                }
-            }
-            throw new Error('无法获取用户信息');
-        }
         const isBuddy = await core.apis.FriendApi.isBuddy(Uid);
         if (!isBuddy) {
             const ret = await core.apis.MsgApi.getTempChatInfo(ChatType.KCHATTYPETEMPC2CFROMGROUP, Uid);
@@ -88,13 +78,7 @@ export async function createContext(core: NapCatCore, payload: OB11PostContext |
             guildId: '',
         };
     }
-    if (contextMode === ContextMode.Private && payload.group_id) {
+    throw new Error('请指定 group_id 或 user_id');
-        throw new Error('当前私聊发送,请指定 user_id 而不是 group_id');
-    }
-    if (contextMode === ContextMode.Group && payload.user_id) {
-        throw new Error('当前群聊发送,请指定 group_id 而不是 user_id');
-    }
-    throw new Error('请指定正确的 group_id 或 user_id');
 }
 
 function getSpecialMsgNum(payload: OB11PostSendMsg, msgType: OB11MessageDataType): number {
@@ -153,25 +137,21 @@ export class SendMsgBase extends OneBotAction<OB11PostSendMsg, ReturnDataType> {
             } else if (returnMsgAndResId.res_id && !returnMsgAndResId.message) {
                 throw Error(`发送转发消息（res_id：${returnMsgAndResId.res_id} 失败`);
             }
-        } else if (await this.getIsFowardOneMsg(messages)) {
+        } else {
-            let onebot_inner_forward = await this.getIsFowardOneMsg(messages);
+            // if (getSpecialMsgNum(payload, OB11MessageDataType.music)) {
-            if (!onebot_inner_forward) throw Error('转发消息失败，未找到消息');
+            //   const music: OB11MessageCustomMusic = messages[0] as OB11MessageCustomMusic;
-            const real_msgid = MessageUnique.getMsgIdAndPeerByShortId(+onebot_inner_forward.data.id)?.MsgId || onebot_inner_forward.data.id;
+            //   if (music) {
-            await this.core.apis.MsgApi.forwardMsg(peer,
+            //   }
-                peer,
+            // }
-                [real_msgid]
-            );
-            // 暂时没办法筛选的委屈办法
-            return { message_id: +onebot_inner_forward.data.id };
         }
+        // log("send msg:", peer, sendElements)
+
         const { sendElements, deleteAfterSentFiles } = await this.obContext.apis.MsgApi
             .createSendElements(messages, peer);
         const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(peer, sendElements, deleteAfterSentFiles);
         return { message_id: returnMsg.id! };
     }
-    private async getIsFowardOneMsg(message: OB11MessageData[]): Promise<OB11MessageForward | undefined> {
+
-        return message.find(msg => msg.type === OB11MessageDataType.forward && isNumeric(msg.data.id)) as OB11MessageForward | undefined;
-    }
     private async uploadForwardedNodesPacket(msgPeer: Peer, messageNodes: OB11MessageNode[], source?: string, news?: {
         text: string
     }[], summary?: string, prompt?: string, parentMeta?: {

src/onebot/action/packet/GetRkeyEx.ts

@@ -1,18 +0,0 @@
-import { ActionName } from '@/onebot/action/router';
-import { GetPacketStatusDepends } from '@/onebot/action/packet/GetPacketStatus';
-
-export class GetRkeyEx extends GetPacketStatusDepends<void, unknown> {
-    override actionName = ActionName.GetRkeyEx;
-
-    async _handle() {
-        let rkeys = await this.core.apis.PacketApi.pkt.operation.FetchRkey();
-        return rkeys.map(rkey => {
-            return {
-                type: rkey.type === 10 ? "private" : "group",
-                rkey: rkey.rkey,
-                created_at: rkey.time,
-                ttl: rkey.ttl,
-            };
-        });
-    }
-}

src/onebot/action/packet/GetRkeyServer.ts

@@ -1,38 +0,0 @@
-import { ActionName } from '@/onebot/action/router';
-import { GetPacketStatusDepends } from '@/onebot/action/packet/GetPacketStatus';
-
-export class GetRkeyServer extends GetPacketStatusDepends<void, { private_rkey?: string; group_rkey?: string; expired_time?: number; name: string }> {
-    override actionName = ActionName.GetRkeyServer;
-
-    private rkeyCache: {
-        private_rkey?: string;
-        group_rkey?: string;
-        expired_time?: number;
-        name: string;
-    } | null = null;
-    private expiryTime: number | null = null;
-
-    async _handle() {
-        // 检查缓存是否有效
-        if (this.expiryTime && this.expiryTime > Math.floor(Date.now() / 1000) && this.rkeyCache) {
-            return this.rkeyCache;
-        }
-
-        // 获取新的 Rkey
-        let rkeys = await this.core.apis.PacketApi.pkt.operation.FetchRkey();
-        let privateRkeyItem = rkeys.filter(rkey => rkey.type === 10)[0];
-        let groupRkeyItem = rkeys.filter(rkey => rkey.type === 20)[0];
-
-        this.expiryTime = Math.floor(Date.now() / 1000) + Math.min(+groupRkeyItem!.ttl.toString(),+privateRkeyItem!.ttl.toString());
-
-        // 更新缓存
-        this.rkeyCache = {
-            private_rkey: privateRkeyItem ? privateRkeyItem.rkey : undefined,
-            group_rkey: groupRkeyItem ? groupRkeyItem.rkey : undefined,
-            expired_time: this.expiryTime,
-            name: "NapCat 4"
-        };
-
-        return this.rkeyCache;
-    }
-}

src/onebot/action/router.ts

@@ -10,8 +10,6 @@ export interface InvalidCheckResult {
 }
 
 export const ActionName = {
-    GetRkeyEx: 'get_rkey',
-    GetRkeyServer: 'get_rkey_server',
     SetGroupRemark: 'set_group_remark',
     NapCat_GetPrivateFileUrl: 'get_private_file_url',
     ClickInlineKeyboardButton: 'click_inline_keyboard_button',
@@ -33,7 +31,7 @@ export const ActionName = {
     SetGroupCard: 'set_group_card',
     SetGroupName: 'set_group_name',
     SetGroupLeave: 'set_group_leave',
-    SetSpecialTitle: 'set_group_special_title',
+    SetSpecialTittle: 'set_group_special_title',
     SetFriendAddRequest: 'set_friend_add_request',
     SetGroupAddRequest: 'set_group_add_request',
     GetLoginInfo: 'get_login_info',
@@ -54,7 +52,7 @@ export const ActionName = {
     GetStatus: 'get_status',
     GetVersionInfo: 'get_version_info',
     // Reboot : 'set_restart',
-    CleanCache : 'clean_cache',
+    // CleanCache : 'clean_cache',
     Exit: 'bot_exit',
     // go-cqhttp
     SetQQProfile: 'set_qq_profile',
@@ -132,10 +130,6 @@ export const ActionName = {
     GetRkey: 'nc_get_rkey',
     GetGroupShutList: 'get_group_shut_list',
 
-    MoveGroupFile: 'move_group_file',
-    TransGroupFile: 'trans_group_file',
-    RenameGroupFile: 'rename_group_file',
-
     GetGuildList: 'get_guild_list',
     GetGuildProfile: 'get_guild_service_profile',
 

src/onebot/action/system/CleanCache.ts

@@ -1,38 +0,0 @@
-import { OneBotAction } from '@/onebot/action/OneBotAction';
-import { ActionName } from '@/onebot/action/router';
-import { unlink, readdir } from 'fs/promises';
-import { join } from 'path';
-
-export class CleanCache extends OneBotAction<void, void> {
-    override actionName = ActionName.CleanCache;
-
-    async _handle() {
-        try {
-            // 获取临时文件夹路径
-            const tempPath = this.core.NapCatTempPath;
-
-            // 读取文件夹中的所有文件
-            const files = await readdir(tempPath);
-
-            // 删除每个文件
-            const deletePromises = files.map(async (file) => {
-                const filePath = join(tempPath, file);
-                try {
-                    await unlink(filePath);
-                    this.core.context.logger.log(`已删除文件: ${filePath}`);
-                } catch (err: unknown) {
-                    this.core.context.logger.log(`删除文件 ${filePath} 失败: ${(err as Error).message}`);
-
-                }
-            });
-
-            // 等待所有删除操作完成
-            await Promise.all(deletePromises);
-
-            this.core.context.logger.log(`临时文件夹清理完成: ${tempPath}`);
-        } catch (err: unknown) {
-            this.core.context.logger.log(`清理缓存失败: ${(err as Error).message}`);
-            throw err;
-        }
-    }
-}

src/onebot/action/user/GetFriendList.ts

@@ -14,22 +14,8 @@ export default class GetFriendList extends OneBotAction<Payload, OB11User[]> {
     override actionName = ActionName.GetFriendList;
     override payloadSchema = SchemaData;
 
-    async _handle(_payload: Payload) {
+    async _handle(payload: Payload) {
-        const buddyMap = await this.core.apis.FriendApi.getBuddyV2SimpleInfoMap();
+        //全新逻辑
-        const isNocache = typeof _payload.no_cache === 'string' ? _payload.no_cache === 'true' : !!_payload.no_cache;
+        return OB11Construct.friends(await this.core.apis.FriendApi.getBuddy(typeof payload.no_cache === 'string' ? payload.no_cache === 'true' : !!payload.no_cache));
-        await Promise.all(
-            Array.from(buddyMap.values()).map(async (buddyInfo) => {
-                try {
-                    const userDetail = await this.core.apis.UserApi.getUserDetailInfo(buddyInfo.coreInfo.uid, isNocache);
-                    const data = buddyMap.get(buddyInfo.coreInfo.uid);
-                    if (data) {
-                        data.qqLevel = userDetail.qqLevel;
-                    }
-                } catch (error) {
-                    this.core.context.logger.logError('获取好友详细信息失败', error);
-                }
-            })
-        );
-        return OB11Construct.friends(Array.from(buddyMap.values()));
     }
-}
+}

src/onebot/api/group.ts

@@ -114,6 +114,7 @@ export class OneBotGroupApi {
     async parseCardChangedEvent(msg: RawMessage) {
         if (msg.senderUin && msg.senderUin !== '0') {
             const member = await this.core.apis.GroupApi.getGroupMember(msg.peerUid, msg.senderUin);
+            await this.core.apis.GroupApi.refreshGroupMemberCachePartial(msg.peerUid, msg.senderUid);
             if (member && member.cardName !== msg.sendMemberName) {
                 const newCardName = msg.sendMemberName ?? '';
                 const event = new OB11GroupCardEvent(this.core, parseInt(msg.peerUid), parseInt(msg.senderUin), newCardName, member.cardName);
@@ -129,6 +130,7 @@ export class OneBotGroupApi {
 
     async parsePaiYiPai(msg: RawMessage, jsonStr: string) {
         const json = JSON.parse(jsonStr);
+
         //判断业务类型
         //Poke事件
         const pokedetail: Array<{ uid: string }> = json.items;
@@ -149,15 +151,14 @@ export class OneBotGroupApi {
     async parseOtherJsonEvent(msg: RawMessage, jsonStr: string, context: InstanceContext) {
         const json = JSON.parse(jsonStr);
         const type = json.items[json.items.length - 1]?.txt;
-        await this.core.apis.GroupApi.refreshGroupMemberCachePartial(msg.peerUid, msg.senderUid);
         if (type === '头衔') {
             const memberUin = json.items[1].param[0];
             const title = json.items[3].txt;
             context.logger.logDebug('收到群成员新头衔消息', json);
             return new OB11GroupTitleEvent(
                 this.core,
-                +msg.peerUid,
+                parseInt(msg.peerUid),
-                +memberUin,
+                parseInt(memberUin),
                 title,
             );
         } else if (type === '移出') {

src/onebot/api/msg.ts

@@ -34,7 +34,7 @@ import { EventType } from '@/onebot/event/OneBotEvent';
 import { encodeCQCode } from '@/onebot/helper/cqcode';
 import { uriToLocalFile } from '@/common/file';
 import { RequestUtil } from '@/common/request';
-import fsPromise from 'node:fs/promises';
+import fsPromise, { constants } from 'node:fs/promises';
 import { OB11FriendAddNoticeEvent } from '@/onebot/event/notice/OB11FriendAddNoticeEvent';
 import { ForwardMsgBuilder } from '@/common/forward-msg-builder';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
@@ -45,7 +45,6 @@ import { OB11GroupAdminNoticeEvent } from '../event/notice/OB11GroupAdminNoticeE
 import { GroupChange, GroupChangeInfo, GroupInvite, PushMsgBody } from '@/core/packet/transformer/proto';
 import { OB11GroupRequestEvent } from '../event/request/OB11GroupRequest';
 import { LRUCache } from '@/common/lru-cache';
-import { cleanTaskQueue } from '@/common/clean-task';
 
 type RawToOb11Converters = {
     [Key in keyof MessageElement as Key extends `${string}Element` ? Key : never]: (
@@ -373,8 +372,7 @@ export class OneBotMsgApi {
                 try {
                     multiMsgs = await this.core.apis.PacketApi.pkt.operation.FetchForwardMsg(element.resId);
                 } catch (e) {
-                    this.core.context.logger.logError(`Protocol FetchForwardMsg fallback failed! 
+                    this.core.context.logger.logError('Protocol FetchForwardMsg fallback failed!', e);
-                    element = ${JSON.stringify(element)} , error=${e})`);
                     return null;
                 }
             }
@@ -556,7 +554,7 @@ export class OneBotMsgApi {
         },
 
         [OB11MessageDataType.voice]: async (sendMsg, context) =>
-            this.core.apis.FileApi.createValidSendPttElement(context,
+            this.core.apis.FileApi.createValidSendPttElement(
                 (await this.handleOb11FileLikeMessage(sendMsg, context)).path),
 
         [OB11MessageDataType.json]: async ({ data: { data } }) => ({
@@ -714,56 +712,6 @@ export class OneBotMsgApi {
         this.obContext = obContext;
         this.core = core;
     }
-    /**
-     * 解析带有JSON标记的文本
-     * @param text 要解析的文本
-     * @returns 解析后的结果数组，每个元素包含类型(text或json)和内容
-     */
-    parseTextWithJson(text: string) {
-        // 匹配<{...}>格式的JSON
-        const regex = /<(\{.*?\})>/g;
-        const parts: Array<{ type: 'text' | 'json', content: string | object }> = [];
-        let lastIndex = 0;
-        let match;
-
-        // 查找所有匹配项
-        while ((match = regex.exec(text)) !== null) {
-            // 添加匹配前的文本
-            if (match.index > lastIndex) {
-                parts.push({
-                    type: 'text',
-                    content: text.substring(lastIndex, match.index)
-                });
-            }
-
-            // 添加JSON部分
-            try {
-                const jsonContent = JSON.parse(match[1] ?? '');
-                parts.push({
-                    type: 'json',
-                    content: jsonContent
-                });
-            } catch (e) {
-                // 如果JSON解析失败，作为普通文本处理
-                parts.push({
-                    type: 'text',
-                    content: match[0]
-                });
-            }
-
-            lastIndex = regex.lastIndex;
-        }
-
-        // 添加最后一部分文本
-        if (lastIndex < text.length) {
-            parts.push({
-                type: 'text',
-                content: text.substring(lastIndex)
-            });
-        }
-
-        return parts;
-    }
 
     async parsePrivateMsgEvent(msg: RawMessage, grayTipElement: GrayTipElement) {
         if (grayTipElement.subElementType == NTGrayTipElementSubTypeV2.GRAYTIP_ELEMENT_SUBTYPE_JSON) {
@@ -1022,6 +970,7 @@ export class OneBotMsgApi {
         });
 
         const timeout = 10000 + (totalSize / 1024 / 256 * 1000);
+
         try {
             const returnMsg = await this.core.apis.MsgApi.sendMsg(peer, sendElements, timeout);
             if (!returnMsg) throw new Error('发送消息失败');
@@ -1034,19 +983,18 @@ export class OneBotMsgApi {
         } catch (error) {
             throw new Error((error as Error).message);
         } finally {
-            cleanTaskQueue.addFiles(deleteAfterSentFiles, timeout);
+            setTimeout(async () => {
-            // setTimeout(async () => {
+                const deletePromises = deleteAfterSentFiles.map(async file => {
-            //     const deletePromises = deleteAfterSentFiles.map(async file => {
+                    try {
-            //         try {
+                        if (await fsPromise.access(file, constants.W_OK).then(() => true).catch(() => false)) {
-            //             if (await fsPromise.access(file, constants.W_OK).then(() => true).catch(() => false)) {
+                            await fsPromise.unlink(file);
-            //                 await fsPromise.unlink(file);
+                        }
-            //             }
+                    } catch (e) {
-            //         } catch (e) {
+                        this.core.context.logger.logError('发送消息删除文件失败', e);
-            //             this.core.context.logger.logError('发送消息删除文件失败', e);
+                    }
-            //         }
+                });
-            //     });
+                await Promise.all(deletePromises);
-            //     await Promise.all(deletePromises);
+            }, 60000);
-            // }, 60000);
         }
     }
 
@@ -1105,8 +1053,6 @@ export class OneBotMsgApi {
                 return 'kick';
             case 3:
                 return 'kick_me';
-            case 129:
-                return 'disband';
             default:
                 return 'kick';
         }
@@ -1267,41 +1213,6 @@ export class OneBotMsgApi {
         } else if (SysMessage.contentHead.type == 528 && SysMessage.contentHead.subType == 39 && SysMessage.body?.msgContent) {
             return await this.obContext.apis.UserApi.parseLikeEvent(SysMessage.body?.msgContent);
         }
-        // else if (SysMessage.contentHead.type == 732 && SysMessage.contentHead.subType == 16 && SysMessage.body?.msgContent) {
-        //     let data_wrap = PBString(2);
-        //     let user_wrap = PBUint64(5);
-        //     let group_wrap = PBUint64(4);
-
-        //     ProtoBuf(class extends ProtoBufBase {
-        //         group = group_wrap;
-        //         content = ProtoBufIn(5, { data: data_wrap, user: user_wrap });
-        //     }).decode(SysMessage.body?.msgContent.slice(7));
-        //     let xml_data = UnWrap(data_wrap);
-        //     let group = UnWrap(group_wrap).toString();
-        //     //let user = UnWrap(user_wrap).toString();
-        //     const parsedParts = this.parseTextWithJson(xml_data);
-        //     //解析JSON
-        //     if (parsedParts[1] && parsedParts[3]) {
-        //         let set_user_id: string = (parsedParts[1].content as { data: string }).data;
-        //         let uid = await this.core.apis.UserApi.getUidByUinV2(set_user_id);
-        //         let new_title: string = (parsedParts[3].content as { text: string }).text;
-        //         console.log(this.core.apis.GroupApi.groupMemberCache.get(group)?.get(uid)?.memberSpecialTitle, new_title)
-        //         if (this.core.apis.GroupApi.groupMemberCache.get(group)?.get(uid)?.memberSpecialTitle == new_title) {
-        //             return;
-        //         }
-        //         await this.core.apis.GroupApi.refreshGroupMemberCachePartial(group, uid);
-        //         //let json_data_1_url_search = new URL((parsedParts[3].content as { url: string }).url).searchParams;
-        //         //let is_new: boolean = json_data_1_url_search.get('isnew') === '1';
-
-        //         //console.log(group, set_user_id, is_new, new_title);
-        //         return new GroupMemberTitle(
-        //             this.core,
-        //             +group,
-        //             +set_user_id,
-        //             new_title
-        //         );
-        //     }
-        // }
         return undefined;
     }
 }

src/onebot/event/notice/OB11GroupDecreaseEvent.ts

@@ -1,7 +1,7 @@
 import { OB11GroupNoticeEvent } from './OB11GroupNoticeEvent';
 import { NapCatCore } from '@/core';
 
-export type GroupDecreaseSubType = 'leave' | 'kick' | 'kick_me' | 'disband';
+export type GroupDecreaseSubType = 'leave' | 'kick' | 'kick_me';
 
 export class OB11GroupDecreaseEvent extends OB11GroupNoticeEvent {
     notice_type = 'group_decrease';
@@ -11,7 +11,7 @@ export class OB11GroupDecreaseEvent extends OB11GroupNoticeEvent {
     constructor(core: NapCatCore, groupId: number, userId: number, operatorId: number, subType: GroupDecreaseSubType = 'leave') {
         super(core, groupId, userId);
         this.group_id = groupId;
-        this.operator_id = operatorId;
+        this.operator_id = operatorId; 
         this.user_id = userId;
         this.sub_type = subType;
     }

src/onebot/helper/data.ts

@@ -20,36 +20,16 @@ export class OB11Construct {
 
     static friends(friends: FriendV2[]): OB11User[] {
         return friends.map(rawFriend => ({
-            birthday_year: rawFriend.baseInfo.birthday_year,
+            ...rawFriend.baseInfo,
-            birthday_month: rawFriend.baseInfo.birthday_month,
+            ...rawFriend.coreInfo,
-            birthday_day: rawFriend.baseInfo.birthday_day,
             user_id: parseInt(rawFriend.coreInfo.uin),
-            age: rawFriend.baseInfo.age,
-            phone_num: rawFriend.baseInfo.phoneNum,
-            email: rawFriend.baseInfo.eMail,
-            category_id: rawFriend.baseInfo.categoryId,
             nickname: rawFriend.coreInfo.nick ?? '',
             remark: rawFriend.coreInfo.remark ?? rawFriend.coreInfo.nick,
             sex: this.sex(rawFriend.baseInfo.sex),
-            level: rawFriend.qqLevel && calcQQLevel(rawFriend.qqLevel) || 0,
+            level: 0,
         }));
     }
-    static friend(friends: FriendV2): OB11User {
+
-        return {
-            birthday_year: friends.baseInfo.birthday_year,
-            birthday_month: friends.baseInfo.birthday_month,
-            birthday_day: friends.baseInfo.birthday_day,
-            user_id: parseInt(friends.coreInfo.uin),
-            age: friends.baseInfo.age,
-            phone_num: friends.baseInfo.phoneNum,
-            email: friends.baseInfo.eMail,
-            category_id: friends.baseInfo.categoryId,
-            nickname: friends.coreInfo.nick ?? '',
-            remark: friends.coreInfo.remark ?? friends.coreInfo.nick,
-            sex: this.sex(friends.baseInfo.sex),
-            level: 0,
-        };
-    }
     static groupMemberRole(role: number): OB11GroupMemberRole | undefined {
         return {
             4: OB11GroupMemberRole.owner,
@@ -93,7 +73,6 @@ export class OB11Construct {
 
     static group(group: Group): OB11Group {
         return {
-            group_all_shut: (+group.groupShutupExpireTime > 0 )? -1 : 0,
             group_remark: group.remarkName,
             group_id: +group.groupCode,
             group_name: group.groupName,

src/onebot/index.ts

@@ -20,8 +20,7 @@ import {
     OB11WebSocketClientAdapter,
     OB11NetworkManager,
     OB11NetworkReloadType,
-    OB11HttpServerAdapter,
+    OB11HttpServerAdapter
-    OB11WebSocketServerAdapter,
 } from '@/onebot/network';
 import { NapCatPathWrapper } from '@/common/path';
 import {
@@ -32,7 +31,6 @@ import {
     OneBotUserApi,
 } from '@/onebot/api';
 import { ActionMap, createActionMap } from '@/onebot/action';
-import { WebUiDataRuntime } from '@/webui/src/helper/Data';
 import { OB11InputStatusEvent } from '@/onebot/event/notice/OB11InputStatusEvent';
 import { MessageUnique } from '@/common/message-unique';
 import { proxiedListenerOf } from '@/common/proxy-handler';
@@ -100,7 +98,7 @@ export class NapCatOneBot11Adapter {
         const selfInfo = this.core.selfInfo;
         const ob11Config = this.configLoader.configData;
 
-        this.core.apis.UserApi.getUserDetailInfo(selfInfo.uid, false)
+        this.core.apis.UserApi.getUserDetailInfo(selfInfo.uid)
             .then((user) => {
                 selfInfo.nick = user.nick;
                 this.context.logger.setLogSelfInfo(selfInfo);
@@ -139,15 +137,6 @@ export class NapCatOneBot11Adapter {
         }
         for (const key of ob11Config.network.websocketServers) {
             if (key.enable) {
-                this.networkManager.registerAdapter(
-                    new OB11WebSocketServerAdapter(
-                        key.name,
-                        key,
-                        this.core,
-                        this,
-                        this.actions
-                    )
-                );
             }
         }
         for (const key of ob11Config.network.websocketClients) {
@@ -168,64 +157,9 @@ export class NapCatOneBot11Adapter {
         this.initMsgListener();
         this.initBuddyListener();
         this.initGroupListener();
-
-        WebUiDataRuntime.setQQVersion(this.core.context.basicInfoWrapper.getFullQQVesion());
-        WebUiDataRuntime.setQQLoginInfo(selfInfo);
-        WebUiDataRuntime.setQQLoginStatus(true);
-        WebUiDataRuntime.setOnOB11ConfigChanged(async (newConfig) => {
-            const prev = this.configLoader.configData;
-            this.configLoader.save(newConfig);
-            //this.context.logger.log(`OneBot11 配置更改：${JSON.stringify(prev)} -> ${JSON.stringify(newConfig)}`);
-            await this.reloadNetwork(prev, newConfig);
-        });
     }
 
 
-    private async reloadNetwork(prev: OneBotConfig, now: OneBotConfig): Promise<void> {
-        const prevLog = await this.creatOneBotLog(prev);
-        const newLog = await this.creatOneBotLog(now);
-        this.context.logger.log(`[Notice] [OneBot11] 配置变更前:\n${prevLog}`);
-        this.context.logger.log(`[Notice] [OneBot11] 配置变更后:\n${newLog}`);
-
-        await this.handleConfigChange(prev.network.httpServers, now.network.httpServers, OB11HttpServerAdapter);
-        await this.handleConfigChange(prev.network.httpClients, now.network.httpClients, OB11HttpClientAdapter);
-        await this.handleConfigChange(prev.network.httpSseServers, now.network.httpSseServers, OB11HttpSSEServerAdapter);
-        await this.handleConfigChange(prev.network.websocketServers, now.network.websocketServers, OB11WebSocketServerAdapter);
-        await this.handleConfigChange(prev.network.websocketClients, now.network.websocketClients, OB11WebSocketClientAdapter);
-    }
-
-    private async handleConfigChange<CT extends NetworkAdapterConfig>(
-        prevConfig: NetworkAdapterConfig[],
-        nowConfig: NetworkAdapterConfig[],
-        adapterClass: new (
-            ...args: ConstructorParameters<typeof IOB11NetworkAdapter<CT>>
-        ) => IOB11NetworkAdapter<CT>
-    ): Promise<void> {
-        // 比较旧的在新的找不到的回收
-        for (const adapterConfig of prevConfig) {
-            const existingAdapter = nowConfig.find((e) => e.name === adapterConfig.name);
-            if (!existingAdapter) {
-                const existingAdapter = this.networkManager.findSomeAdapter(adapterConfig.name);
-                if (existingAdapter) {
-                    await this.networkManager.closeSomeAdaterWhenOpen([existingAdapter]);
-                }
-            }
-        }
-        // 通知新配置重载 删除关闭的 加入新开的
-        for (const adapterConfig of nowConfig) {
-            const existingAdapter = this.networkManager.findSomeAdapter(adapterConfig.name);
-            if (existingAdapter) {
-                const networkChange = await existingAdapter.reload(adapterConfig);
-                if (networkChange === OB11NetworkReloadType.NetWorkClose) {
-                    await this.networkManager.closeSomeAdaterWhenOpen([existingAdapter]);
-                }
-            } else if (adapterConfig.enable) {
-                const newAdapter = new adapterClass(adapterConfig.name, adapterConfig as CT, this.core, this, this.actions);
-                await this.networkManager.registerAdapterAndOpen(newAdapter);
-            }
-        }
-    }
-
     private initMsgListener() {
         const msgListener = new NodeIKernelMsgListener();
         msgListener.onRecvSysMsg = (msg) => {

src/onebot/network/http-server-sse.ts

@@ -1,33 +1,59 @@
 import { OB11EmitEventContent } from './index';
-import { Request, Response } from 'express';
 import { OB11HttpServerAdapter } from './http-server';
+import { Context } from 'hono';
+import { SSEStreamingApi, streamSSE } from 'hono/streaming';
+import { Mutex } from 'async-mutex';
+import { LifeCycleSubType, OB11LifeCycleEvent } from '../event/meta/OB11LifeCycleEvent';
 
 export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
-    private sseClients: Response[] = [];
+    private sseClients: { context: Context; stream: SSEStreamingApi, mutex: Mutex }[] = [];
 
-    override async handleRequest(req: Request, res: Response) {
+    override async actionHandler(c: Context): Promise<any> {
-        if (req.path === '/_events') {
+        if (c.req.path === '/_events') {
-            this.createSseSupport(req, res);
+            return await this.createSseSupport(c);
         } else {
-            super.httpApiRequest(req, res);
+            return super.actionHandler(c);
         }
     }
 
-    private async createSseSupport(req: Request, res: Response) {
+    private async createSseSupport(c: Context) {
-        res.setHeader('Content-Type', 'text/event-stream');
+        return streamSSE(c, async (stream) => {
-        res.setHeader('Cache-Control', 'no-cache');
+            const client = { context: c, stream, mutex: new Mutex() };
-        res.setHeader('Connection', 'keep-alive');
+            this.sseClients.push(client);
-        res.flushHeaders();
+            client.mutex.acquire();
 
-        this.sseClients.push(res);
+            stream.onAbort(() => {
-        req.on('close', () => {
+                this.removeClient(stream);
-            this.sseClients = this.sseClients.filter((client) => client !== res);
+                client.mutex.release();
+            });
+
+            await stream.writeSSE({ data: JSON.stringify(new OB11LifeCycleEvent(this.core, LifeCycleSubType.CONNECT)) });
+            await client.mutex.waitForUnlock();
         });
     }
 
+    private removeClient(stream: SSEStreamingApi) {
+        const index = this.sseClients.findIndex(client => client.stream === stream);
+        if (index !== -1) {
+            this.sseClients.splice(index, 1);
+        }
+    }
+
     override onEvent<T extends OB11EmitEventContent>(event: T) {
-        this.sseClients.forEach((res) => {
+        const eventData = JSON.stringify(event);
-            res.write(`data: ${JSON.stringify(event)}\n\n`);
+
+        Promise.all(
+            this.sseClients.map(async ({ stream, mutex }) => {
+                try {
+                    await stream.writeSSE({ data: eventData });
+                } catch (error) {
+                    mutex.release();
+                    this.removeClient(stream);
+                }
+            })
+        ).then().catch((error) => {
+            this.core.context.logger.logError('Error sending SSE event:', error);
         });
+
     }
-}
+}

src/onebot/network/http-server.ts

@@ -1,19 +1,17 @@
 import { OB11EmitEventContent, OB11NetworkReloadType } from './index';
-import express, { Express, NextFunction, Request, Response } from 'express';
+import { Context, Hono, Next } from 'hono';
-import http from 'http';
 import { NapCatCore } from '@/core';
 import { OB11Response } from '@/onebot/action/OneBotAction';
 import { ActionMap } from '@/onebot/action';
-import cors from 'cors';
+import { cors } from 'hono/cors';
 import { HttpServerConfig } from '@/onebot/config/config';
 import { NapCatOneBot11Adapter } from '@/onebot';
 import { IOB11NetworkAdapter } from '@/onebot/network/adapter';
-import json5 from 'json5';
+import { serve } from '@hono/node-server';
-import { isFinished } from 'on-finished';
+
-import typeis from 'type-is';
 export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig> {
-    private app: Express | undefined;
+    private app: Hono | undefined;
-    private server: http.Server | undefined;
+    private server: ReturnType<typeof serve> | undefined;
 
     constructor(name: string, config: HttpServerConfig, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap) {
         super(name, config, core, obContext, actions);
@@ -27,17 +25,14 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
     open() {
         try {
             if (this.isEnable) {
-                this.core.context.logger.logError('Cannot open a closed HTTP server');
+                this.core.context.logger.logError('[OneBot] [HTTP Server Adapter] 无法打开已经启动的HTTP服务器');
                 return;
             }
-            if (!this.isEnable) {
+            this.initializeServer();
-                this.initializeServer();
+            this.isEnable = true;
-                this.isEnable = true;
-            }
         } catch (e) {
-            this.core.context.logger.logError(`[OneBot] [HTTP Server Adapter] Boot Error: ${e}`);
+            this.core.context.logger.logError(`[OneBot] [HTTP Server Adapter] 启动错误: ${e}`);
         }
-
     }
 
     async close() {
@@ -46,101 +41,159 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
         this.app = undefined;
     }
 
-
     private initializeServer() {
-        this.app = express();
+        this.app = new Hono();
-        this.server = http.createServer(this.app);
 
+        // 注册全局中间件
         this.app.use(cors());
-        this.app.use(express.urlencoded({ extended: true, limit: '5000mb' }));
+        this.app.use(this.authMiddleware.bind(this));
+        this.app.use(this.statusCheckMiddleware.bind(this));
+        this.app.use(this.payloadParserMiddleware.bind(this));
 
-        this.app.use((req, res, next) => {
+        // 注册路由
-            if (isFinished(req)) {
+        this.app.get('/', this.rootHandler.bind(this));
-                next();
+        this.app.all('/*', this.actionHandler.bind(this));
-                return;
+
-            }
+        // 启动服务器
-            if (!typeis.hasBody(req)) {
+        this.server = serve({
-                next();
+            fetch: this.app.fetch.bind(this.app),
-                return;
+            port: this.config.port,
-            }
-            // 兼容处理没有带content-type的请求
-            req.headers['content-type'] = 'application/json';
-            let rawData = '';
-            req.on('data', (chunk) => {
-                rawData += chunk;
-            });
-            req.on('end', () => {
-                try {
-                    req.body = { ...json5.parse(rawData || '{}'), ...req.body };
-                    next();
-                } catch {
-                    return res.status(400).send('Invalid JSON');
-                }
-                return;
-            });
-            req.on('error', () => {
-                return res.status(400).send('Invalid JSON');
-            });
-        });
-        //@ts-expect-error authorize
-        this.app.use((req, res, next) => this.authorize(this.config.token, req, res, next));
-        this.app.use(async (req, res) => {
-            await this.handleRequest(req, res);
-        });
-        this.server.listen(this.config.port, () => {
-            this.core.context.logger.log(`[OneBot] [HTTP Server Adapter] Start On Port ${this.config.port}`);
         });
+
+        this.core.context.logger.log(`[OneBot] [HTTP Server Adapter] 服务器已启动于端口 ${this.config.port}`);
     }
 
-    private authorize(token: string | undefined, req: Request, res: Response, next: NextFunction) {
+    /**
-        if (!token || token.length == 0) return next();//客户端未设置密钥
+     * 身份验证中间件
-        const HeaderClientToken = req.headers.authorization?.split('Bearer ').pop() || '';
+     */
-        const QueryClientToken = req.query['access_token'];
+    private async authMiddleware(c: Context, next: Next) {
-        const ClientToken = typeof (QueryClientToken) === 'string' && QueryClientToken !== '' ? QueryClientToken : HeaderClientToken;
+        const token = this.config.token;
-        if (ClientToken === token) {
+        if (!token || token.length === 0) {
+            return next(); // 未配置token，跳过验证
+        }
+
+        // 从请求头或查询参数获取token
+        const headerToken = c.req.header('authorization')?.split('Bearer ').pop() || '';
+        const queryToken = c.req.query('access_token');
+        const clientToken = typeof queryToken === 'string' && queryToken !== ''
+            ? queryToken
+            : headerToken;
+
+        if (clientToken === token) {
             return next();
-        } else {
+        }
-            return res.status(403).send(JSON.stringify({ message: 'token verify failed!' }));
+
+        // 验证失败
+        c.status(403);
+        return c.json({ message: 'token验证失败' });
+    }
+
+    /**
+     * 服务器状态检查中间件
+     */
+    private async statusCheckMiddleware(c: Context, next: Next) {
+        if (!this.isEnable) {
+            this.core.context.logger.log('[OneBot] [HTTP Server Adapter] 服务器已关闭');
+            return c.json(OB11Response.error('服务器已关闭', 200));
+        }
+        return next();
+    }
+
+    /**
+     * 请求参数解析中间件
+     * 按优先级解析请求参数：JSON > 表单 > 查询参数
+     */
+    private async payloadParserMiddleware(c: Context, next: Next) {
+        try {
+            // 初始化payload对象
+            let payload: Record<string, any> = {};
+
+            // 1. 提取查询参数
+            const queryParams = c.req.query();
+            if (Object.keys(queryParams).length > 0) {
+                payload = { ...queryParams };
+            }
+
+            // 2. 解析请求体
+            const contentType = c.req.header('content-type') || '';
+            let bodyData = {};
+
+            try {
+                // 优先尝试以JSON格式解析
+                if (contentType.includes('application/json') || contentType === '' || contentType.includes('text/plain')) {
+                    try {
+                        bodyData = await c.req.json();
+                    } catch {
+                        // JSON解析失败时，尝试其他方式
+                    }
+                }
+
+                // 如果JSON解析失败或不是JSON格式，尝试其他格式
+                if (Object.keys(bodyData).length === 0) {
+                    if (contentType.includes('application/x-www-form-urlencoded') ||
+                        contentType.includes('multipart/form-data')) {
+                        bodyData = await c.req.parseBody();
+                    } else if (contentType) {
+                        // 尝试通用解析
+                        bodyData = await c.req.parseBody();
+                    }
+                }
+            } catch (parseError) {
+                // 所有解析方式都失败，记录错误但继续处理
+                this.core.context.logger.log(`[OneBot] [HTTP Server Adapter] 请求体解析失败: ${parseError}`);
+            }
+
+            // 3. 合并参数
+            payload = { ...payload, ...bodyData };
+
+            // 4. 将解析结果保存到上下文
+            c.set('payload', payload);
+            return next();
+        } catch (error) {
+            this.core.context.logger.logError(`[OneBot] [HTTP Server Adapter] 请求处理错误: ${error}`);
+            return c.json(OB11Response.error(`参数解析失败: ${(error as Error)?.message || '未知错误'}`, 200));
         }
     }
 
-    async httpApiRequest(req: Request, res: Response) {
+    /**
-        let payload = req.body;
+     * 根路径处理器
-        if (req.method == 'get') {
+     */
-            payload = req.query;
+    private rootHandler(c: Context) {
-        } else if (req.query) {
+        const response = OB11Response.ok({});
-            payload = { ...req.body, ...req.query };
+        response.message = 'NapCat4 Is Running';
-        }
+        return c.json(response);
-        if (req.path === '' || req.path === '/') {
+    }
-            const hello = OB11Response.ok({});
+
-            hello.message = 'NapCat4 Is Running';
+    /**
-            return res.json(hello);
+     * API动作处理器
-        }
+     */
-        const actionName = req.path.split('/')[1];
+    async actionHandler(c: Context) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        try {
-        const action = this.actions.get(actionName as any);
+            const payload = c.get('payload') as Record<string, any>;
-        if (action) {
+            const actionName = c.req.path.split('/')[1];
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const action = this.actions.get(actionName as any);
+
+            if (!action) {
+                return c.json(OB11Response.error(`不支持的API: ${actionName}`, 200));
+            }
+
             try {
                 const result = await action.handle(payload, this.name, this.config);
-                return res.json(result);
+                return c.json(result);
             } catch (error: unknown) {
-                return res.json(OB11Response.error((error as Error)?.stack?.toString() || (error as Error)?.message || 'Error Handle', 200));
+                const errorMessage = (error as Error)?.stack || (error as Error)?.message || 'Error Handle';
+                this.core.context.logger.logError(`[OneBot] [HTTP Server Adapter] API处理错误: ${errorMessage}`);
+                return c.json(OB11Response.error(errorMessage, 200));
             }
-        } else {
+        } catch (error: unknown) {
-            return res.json(OB11Response.error('不支持的Api ' + actionName, 200));
+            const errorMessage = (error as Error)?.message || '未知错误';
+            this.core.context.logger.logError(`[OneBot] [HTTP Server Adapter] 请求处理失败: ${errorMessage}`);
+            return c.json(OB11Response.error(`请求处理失败: ${errorMessage}`, 200));
         }
     }
 
-    async handleRequest(req: Request, res: Response) {
-        if (!this.isEnable) {
-            this.core.context.logger.log('[OneBot] [HTTP Server Adapter] Server is closed');
-            res.json(OB11Response.error('Server is closed', 200));
-            return;
-        }
-        this.httpApiRequest(req, res);
-        return;
-    }
-
     async reload(newConfig: HttpServerConfig) {
         const wasEnabled = this.isEnable;
         const oldPort = this.config.port;
@@ -164,4 +217,4 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
 
         return OB11NetworkReloadType.Normal;
     }
-}
+}

src/onebot/network/index.ts

@@ -103,5 +103,4 @@ export class OB11NetworkManager {
 
 export * from './http-client';
 export * from './websocket-client';
-export * from './http-server';
+export * from './http-server';
-export * from './websocket-server';

src/onebot/network/websocket-client.ts

@@ -1,5 +1,4 @@
 import { OB11EmitEventContent, OB11NetworkReloadType } from '@/onebot/network/index';
-import { RawData, WebSocket } from 'ws';
 import { OB11HeartbeatEvent } from '@/onebot/event/meta/OB11HeartbeatEvent';
 import { NapCatCore } from '@/core';
 import { ActionName } from '@/onebot/action/router';
@@ -10,10 +9,12 @@ import { WebsocketClientConfig } from '@/onebot/config/config';
 import { NapCatOneBot11Adapter } from '@/onebot';
 import { IOB11NetworkAdapter } from '@/onebot/network/adapter';
 import json5 from 'json5';
+import { hc } from 'hono/client';
 
 export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketClientConfig> {
     private connection: WebSocket | null = null;
     private heartbeatRef: NodeJS.Timeout | null = null;
+    private client = hc(this.config.url);
 
     constructor(name: string, config: WebsocketClientConfig, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap) {
         super(name, config, core, obContext, actions);
@@ -37,13 +38,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
             }, this.config.heartInterval);
         }
         this.isEnable = true;
-        try {
+        await this.tryConnect();
-            await this.tryConnect();
-        } catch (error) {
-            this.logger.logError('[OneBot] [WebSocket Client] TryConnect Error , info -> ', error);
-
-        }
-
     }
 
     close() {
@@ -71,37 +66,23 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
     private async tryConnect() {
         if (!this.connection && this.isEnable) {
             let isClosedByError = false;
+            let wsClientX = this.client['ws']?.$ws(0);
+            if (!wsClientX) throw new Error('WebSocket Client Error');
+            this.connection = wsClientX;
 
-            this.connection = new WebSocket(this.config.url, {
+            this.connection.addEventListener('open', () => {
-                maxPayload: 1024 * 1024 * 1024,
-                handshakeTimeout: 2000,
-                perMessageDeflate: false,
-                headers: {
-                    'X-Self-ID': this.core.selfInfo.uin,
-                    'Authorization': `Bearer ${this.config.token}`,
-                    'x-client-role': 'Universal',  // 为koishi adpter适配
-                    'User-Agent': 'OneBot/11',
-                },
-
-            });
-            this.connection.on('ping', () => {
-                this.connection?.pong();
-            });
-            this.connection.on('pong', () => {
-                //this.logger.logDebug('[OneBot] [WebSocket Client] 收到pong');
-            });
-            this.connection.on('open', () => {
                 try {
                     this.connectEvent(this.core);
                 } catch (e) {
                     this.logger.logError('[OneBot] [WebSocket Client] 发送连接生命周期失败', e);
                 }
+            });
 
+            this.connection.addEventListener('message', (event) => {
+                this.handleMessage(event.data);
             });
-            this.connection.on('message', (data) => {
+
-                this.handleMessage(data);
+            this.connection.addEventListener('close', () => {
-            });
-            this.connection.once('close', () => {
                 if (!isClosedByError) {
                     this.logger.logError(`[OneBot] [WebSocket Client] 反向WebSocket (${this.config.url}) 连接意外关闭`);
                     this.logger.logError(`[OneBot] [WebSocket Client] 在 ${Math.floor(this.config.reconnectInterval / 1000)} 秒后尝试重新连接`);
@@ -111,7 +92,8 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
                     }
                 }
             });
-            this.connection.on('error', (err) => {
+
+            this.connection.addEventListener('error', (err) => {
                 isClosedByError = true;
                 this.logger.logError(`[OneBot] [WebSocket Client] 反向WebSocket (${this.config.url}) 连接错误`, err);
                 this.logger.logError(`[OneBot] [WebSocket Client] 在 ${Math.floor(this.config.reconnectInterval / 1000)} 秒后尝试重新连接`);
@@ -130,7 +112,8 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
             this.logger.logError('[OneBot] [WebSocket Client] 发送生命周期失败', e);
         }
     }
-    private async handleMessage(message: RawData) {
+
+    private async handleMessage(message: MessageEvent) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let receiveData: { action: typeof ActionName[keyof typeof ActionName], params?: any, echo?: any } = { action: ActionName.Unknown, params: {} };
         let echo = undefined;
@@ -154,6 +137,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config);
         this.checkStateAndReply<unknown>({ ...retdata });
     }
+
     async reload(newConfig: WebsocketClientConfig) {
         const wasEnabled = this.isEnable;
         const oldUrl = this.config.url;
@@ -193,4 +177,4 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
 
         return OB11NetworkReloadType.Normal;
     }
-}
+}

src/onebot/network/websocket-server.ts

@@ -1,196 +1,210 @@
 import { OB11EmitEventContent, OB11NetworkReloadType } from './index';
-import urlParse from 'url';
-import { RawData, WebSocket, WebSocketServer } from 'ws';
-import { Mutex } from 'async-mutex';
-import { OB11Response } from '@/onebot/action/OneBotAction';
-import { ActionName } from '@/onebot/action/router';
 import { NapCatCore } from '@/core';
-import { OB11HeartbeatEvent } from '@/onebot/event/meta/OB11HeartbeatEvent';
-import { IncomingMessage } from 'http';
 import { ActionMap } from '@/onebot/action';
-import { LifeCycleSubType, OB11LifeCycleEvent } from '@/onebot/event/meta/OB11LifeCycleEvent';
 import { WebsocketServerConfig } from '@/onebot/config/config';
 import { NapCatOneBot11Adapter } from '@/onebot';
 import { IOB11NetworkAdapter } from '@/onebot/network/adapter';
-import json5 from 'json5';
+import { serve } from '@hono/node-server';
+import { Context, Hono } from 'hono';
+import { createNodeWebSocket } from '@hono/node-ws';
+import { WSContext, WSMessageReceive } from 'hono/ws';
+import { OB11Response } from '../action/OneBotAction';
+import { ActionName } from '../action/router';
+import { OB11HeartbeatEvent } from '@/onebot/event/meta/OB11HeartbeatEvent';
+import { LifeCycleSubType, OB11LifeCycleEvent } from '@/onebot/event/meta/OB11LifeCycleEvent';
 
-export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketServerConfig> {
+export class OB11WebsocketServerAdapter extends IOB11NetworkAdapter<WebsocketServerConfig> {
-    wsServer?: WebSocketServer;
+    private app: Hono | undefined;
-    wsClients: WebSocket[] = [];
+    private server: ReturnType<typeof serve> | undefined;
-    wsClientsMutex = new Mutex();
+    private clients: Set<WSContext<any>> = new Set();
+    private eventClients: Set<WSContext<any>> = new Set(); // 仅用于接收事件的客户端
     private heartbeatIntervalId: NodeJS.Timeout | null = null;
-    wsClientWithEvent: WebSocket[] = [];
 
-    constructor(
+    constructor(name: string, config: WebsocketServerConfig, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap) {
-        name: string, config: WebsocketServerConfig, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap
-    ) {
         super(name, config, core, obContext, actions);
-        this.wsServer = new WebSocketServer({
-            port: this.config.port,
-            host: this.config.host === '0.0.0.0' ? '' : this.config.host,
-            maxPayload: 1024 * 1024 * 1024,
-        });
-        this.createServer(this.wsServer);
-
     }
-    createServer(newServer: WebSocketServer) {
-        newServer.on('connection', async (wsClient, wsReq) => {
-            if (!this.isEnable) {
-                wsClient.close();
-                return;
-            }
-            //鉴权
-            this.authorize(this.config.token, wsClient, wsReq);
-            const paramUrl = wsReq.url?.indexOf('?') !== -1 ? wsReq.url?.substring(0, wsReq.url?.indexOf('?')) : wsReq.url;
-            const isApiConnect = paramUrl === '/api' || paramUrl === '/api/';
-            if (!isApiConnect) {
-                this.connectEvent(this.core, wsClient);
-            }
 
-            wsClient.on('error', (err) => this.logger.log('[OneBot] [WebSocket Server] Client Error:', err.message));
+    override onEvent<T extends OB11EmitEventContent>(event: T) {
-            wsClient.on('message', (message) => {
+        if (!this.isEnable || this.eventClients.size === 0) return;
-                this.handleMessage(wsClient, message).then().catch(e => this.logger.logError(e));
-            });
-            wsClient.on('ping', () => {
-                wsClient.pong();
-            });
-            wsClient.on('pong', () => {
-                //this.logger.logDebug('[OneBot] [WebSocket Server] Pong received');
-            });
-            wsClient.once('close', () => {
-                this.wsClientsMutex.runExclusive(async () => {
-                    const NormolIndex = this.wsClients.indexOf(wsClient);
-                    if (NormolIndex !== -1) {
-                        this.wsClients.splice(NormolIndex, 1);
-                    }
-                    const EventIndex = this.wsClientWithEvent.indexOf(wsClient);
-                    if (EventIndex !== -1) {
-                        this.wsClientWithEvent.splice(EventIndex, 1);
-                    }
 
-                });
-            });
-            await this.wsClientsMutex.runExclusive(async () => {
-                if (!isApiConnect) {
-                    this.wsClientWithEvent.push(wsClient);
-                }
-                this.wsClients.push(wsClient);
-            });
-        }).on('error', (err) => this.logger.log('[OneBot] [WebSocket Server] Server Error:', err.message));
-    }
-    connectEvent(core: NapCatCore, wsClient: WebSocket) {
         try {
-            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT), wsClient);
+            const eventData = JSON.stringify(event);
-        } catch (e) {
+            this.eventClients.forEach(client => {
-            this.logger.logError('[OneBot] [WebSocket Server] 发送生命周期失败', e);
+                try {
-        }
+                    client.send(eventData);
-    }
+                } catch (e) {
-
+                    this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] 向客户端发送事件失败: ${e}`);
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+                }
-        this.wsClientsMutex.runExclusive(async () => {
-            this.wsClientWithEvent.forEach((wsClient) => {
-                wsClient.send(JSON.stringify(event));
             });
-        });
+
+            if (this.config.debug) {
+                this.core.context.logger.logDebug(`[OneBot] [Websocket Server Adapter] 已广播事件到 ${this.eventClients.size} 个客户端`);
+            }
+        } catch (e) {
+            this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] 事件序列化失败: ${e}`);
+        }
     }
 
     open() {
-        if (this.isEnable) {
+        try {
-            this.logger.logError('[OneBot] [WebSocket Server] Cannot open a opened WebSocket server');
+            if (this.isEnable) {
-            return;
+                this.core.context.logger.logError('[OneBot] [Websocket Server Adapter] 无法打开已经启动的Websocket服务器');
-        }
+                return;
-        const addressInfo = this.wsServer?.address();
+            }
-        this.logger.log('[OneBot] [WebSocket Server] Server Started', typeof (addressInfo) === 'string' ? addressInfo : addressInfo?.address + ':' + addressInfo?.port);
+            this.initializeServer();
+            this.isEnable = true;
 
-        this.isEnable = true;
+            // 启动心跳
-        if (this.config.heartInterval > 0) {
+            if (this.config.heartInterval > 0) {
-            this.registerHeartBeat();
+                this.registerHeartBeat();
+            }
+        } catch (e) {
+            this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] 启动错误: ${e}`);
         }
-
     }
 
     async close() {
         this.isEnable = false;
-        this.wsServer?.close((err) => {
+        this.clients.clear();
-            if (err) {
+        this.eventClients.clear();
-                this.logger.logError('[OneBot] [WebSocket Server] Error closing server:', err.message);
-            } else {
-                this.logger.log('[OneBot] [WebSocket Server] Server Closed');
-            }
 
-        });
+        // 清除心跳定时器
         if (this.heartbeatIntervalId) {
             clearInterval(this.heartbeatIntervalId);
             this.heartbeatIntervalId = null;
         }
-        await this.wsClientsMutex.runExclusive(async () => {
+
-            this.wsClients.forEach((wsClient) => {
+        this.server?.close();
-                wsClient.close();
+        this.app = undefined;
-            });
-            this.wsClients = [];
-            this.wsClientWithEvent = [];
-        });
     }
 
     private registerHeartBeat() {
         this.heartbeatIntervalId = setInterval(() => {
-            this.wsClientsMutex.runExclusive(async () => {
+            if (!this.isEnable || this.eventClients.size === 0) return;
-                this.wsClientWithEvent.forEach((wsClient) => {
+
-                    if (wsClient.readyState === WebSocket.OPEN) {
+            try {
-                        wsClient.send(JSON.stringify(new OB11HeartbeatEvent(this.core, this.config.heartInterval, this.core.selfInfo.online ?? true, true)));
+                const heartbeatEvent = new OB11HeartbeatEvent(
+                    this.core,
+                    this.config.heartInterval,
+                    this.core.selfInfo.online ?? true,
+                    true
+                );
+
+                const eventData = JSON.stringify(heartbeatEvent);
+                this.eventClients.forEach(client => {
+                    try {
+                        client.send(eventData);
+                    } catch (e) {
+                        this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] 发送心跳失败: ${e}`);
                     }
                 });
-            });
+            } catch (e) {
+                this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] 心跳事件生成失败: ${e}`);
+            }
         }, this.config.heartInterval);
     }
 
-    private authorize(token: string | undefined, wsClient: WebSocket, wsReq: IncomingMessage) {
+    private initializeServer() {
-        if (!token || token.length == 0) return;//客户端未设置密钥
+        this.app = new Hono();
-        const QueryClientToken = urlParse.parse(wsReq?.url || '', true).query['access_token'];
+        const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app: this.app });
-        const HeaderClientToken = wsReq.headers.authorization?.split('Bearer ').pop() || '';
+
-        const ClientToken = typeof (QueryClientToken) === 'string' && QueryClientToken !== '' ? QueryClientToken : HeaderClientToken;
+        // 处理所有WebSocket请求
-        if (ClientToken === token) {
+        this.app.all('/*', upgradeWebSocket((c) => {
+            // 鉴权处理
+            if (this.config.token && this.config.token.length > 0) {
+                const url = new URL(c.req.url, `http://${c.req.header('host') || 'localhost'}`);
+                const queryToken = url.searchParams.get('access_token');
+                const authHeader = c.req.header('authorization');
+                const headerToken = authHeader?.startsWith('Bearer ') ? authHeader.substring(7) : '';
+                const clientToken = queryToken || headerToken;
+
+                if (clientToken !== this.config.token) {
+                    return {
+                        onOpen: (_evt, ws) => {
+                            ws.send(JSON.stringify(OB11Response.res(null, 'failed', 1403, 'token验证失败')));
+                            ws.close();
+                        }
+                    };
+                }
+            }
+
+            // 判断连接类型
+            const url = new URL(c.req.url, `http://${c.req.header('host') || 'localhost'}`);
+            const path = url.pathname;
+            const isApiConnect = path === '/api' || path === '/api/';
+
+            return {
+                onOpen: (_evt, ws) => {
+                    this.clients.add(ws);
+
+                    // 仅对非API连接添加到事件客户端列表
+                    if (!isApiConnect) {
+                        this.eventClients.add(ws);
+                        // 发送连接生命周期事件
+                        try {
+                            ws.send(JSON.stringify(new OB11LifeCycleEvent(this.core, LifeCycleSubType.CONNECT)));
+                        } catch (e) {
+                            this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] 发送生命周期事件失败: ${e}`);
+                        }
+                    }
+
+                    this.core.context.logger.log(`[OneBot] [Websocket Server Adapter] 客户端已连接，类型: ${isApiConnect ? 'API' : '事件'}，当前连接数: ${this.clients.size}`);
+                },
+                onMessage: (evt, ws) => {
+                    this.actionHandler(c, evt, ws);
+                },
+                onClose: (_evt, ws) => {
+                    this.clients.delete(ws);
+                    this.eventClients.delete(ws);
+                    this.core.context.logger.log(`[OneBot] [Websocket Server Adapter] 客户端已断开，当前连接数: ${this.clients.size}`);
+                },
+                onError: (error) => {
+                    this.core.context.logger.logError(`[OneBot] [Websocket Server Adapter] WebSocket错误: ${error}`);
+                }
+            };
+        }));
+
+        // 启动服务器
+        this.server = serve({
+            fetch: this.app.fetch.bind(this.app),
+            port: this.config.port,
+            hostname: this.config.host === '0.0.0.0' ? undefined : this.config.host,
+        });
+
+        injectWebSocket(this.server);
+        this.core.context.logger.log(`[OneBot] [Websocket Server Adapter] 服务器已启动于 ${this.config.host}:${this.config.port}`);
+    }
+
+    async actionHandler<T>(_c: Context, evt: MessageEvent<WSMessageReceive>, ws: WSContext<T>) {
+        const { data } = evt;
+        if (typeof data !== 'string') {
+            this.core.context.logger.logError('[OneBot] [Websocket Server Adapter] 收到非字符串消息');
             return;
         }
-        wsClient.send(JSON.stringify(OB11Response.res(null, 'failed', 1403, 'token验证失败')));
-        wsClient.close();
-    }
-
-    private checkStateAndReply<T>(data: T, wsClient: WebSocket) {
-        if (wsClient.readyState === WebSocket.OPEN) {
-            wsClient.send(JSON.stringify(data));
-        }
-    }
-
-    private async handleMessage(wsClient: WebSocket, message: RawData) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let receiveData: { action: typeof ActionName[keyof typeof ActionName], params?: any, echo?: any } = { action: ActionName.Unknown, params: {} };
         let echo = undefined;
         try {
-            receiveData = json5.parse(message.toString());
+            receiveData = JSON.parse(data);
             echo = receiveData.echo;
-            //this.logger.logDebug('收到正向Websocket消息', receiveData);
         } catch {
-            this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo), wsClient);
+            return ws.send(JSON.stringify(OB11Response.error('json解析失败,请检查数据格式', 1400, echo)));
-            return;
         }
-        receiveData.params = (receiveData?.params) ? receiveData.params : {};//兼容类型验证 不然类型校验爆炸
+        receiveData.params = (receiveData?.params) ? receiveData.params : {}; // 兼容类型验证
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const action = this.actions.get(receiveData.action as any);
         if (!action) {
             this.logger.logError('[OneBot] [WebSocket Client] 发生错误', '不支持的API ' + receiveData.action);
-            this.checkStateAndReply<unknown>(OB11Response.error('不支持的API ' + receiveData.action, 1404, echo), wsClient);
+            return ws.send(JSON.stringify(OB11Response.error('不支持的API ' + receiveData.action, 1404, echo)));
-            return;
         }
         const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config);
-        this.checkStateAndReply<unknown>({ ...retdata }, wsClient);
+        ws.send(JSON.stringify({ ...retdata }));
     }
 
     async reload(newConfig: WebsocketServerConfig) {
         const wasEnabled = this.isEnable;
         const oldPort = this.config.port;
         const oldHost = this.config.host;
-        const oldHeartbeatInterval = this.config.heartInterval;
+        const oldHeartInterval = this.config.heartInterval;
         this.config = newConfig;
 
         if (newConfig.enable && !wasEnabled) {
@@ -201,21 +215,17 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
             return OB11NetworkReloadType.NetWorkClose;
         }
 
+        // 端口或主机变更需要重启服务器
         if (oldPort !== newConfig.port || oldHost !== newConfig.host) {
             this.close();
-            this.wsServer = new WebSocketServer({
-                port: newConfig.port,
-                host: newConfig.host === '0.0.0.0' ? '' : newConfig.host,
-                maxPayload: 1024 * 1024 * 1024,
-            });
-            this.createServer(this.wsServer);
             if (newConfig.enable) {
                 this.open();
             }
             return OB11NetworkReloadType.NetWorkReload;
         }
 
-        if (oldHeartbeatInterval !== newConfig.heartInterval) {
+        // 心跳间隔变更需要重新设置心跳
+        if (oldHeartInterval !== newConfig.heartInterval) {
             if (this.heartbeatIntervalId) {
                 clearInterval(this.heartbeatIntervalId);
                 this.heartbeatIntervalId = null;
@@ -228,5 +238,4 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
 
         return OB11NetworkReloadType.Normal;
     }
-}
+}
-

src/onebot/types/data.ts

@@ -1,10 +1,4 @@
 export interface OB11User {
-    birthday_year?: number; // 生日
-    birthday_month?: number; // 生日
-    birthday_day?: number; // 生日
-    phone_num?: string; // 手机号
-    email?: string; // 邮箱
-    category_id?: number; // 分组ID
     user_id: number; // 用户ID
     nickname: string; // 昵称
     remark?: string; // 备注
@@ -63,7 +57,6 @@ export interface OB11GroupMember {
 }
 
 export interface OB11Group {
-    group_all_shut: number; // 群全员禁言
     group_remark: string; // 群备注
     group_id: number; // 群ID
     group_name: string; // 群名称

src/shell/base.ts

@@ -26,14 +26,10 @@ import { LoginListItem, NodeIKernelLoginService } from '@/core/services';
 import { program } from 'commander';
 import qrcode from '@/qrcode/lib/main';
 import { NapCatOneBot11Adapter } from '@/onebot';
-import { InitWebUi } from '@/webui';
-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) => {
@@ -141,11 +137,9 @@ async function handleLogin(
     loginListener.onLoginConnected = () => {
         waitForNetworkConnection(loginService, logger).then(() => {
             handleLoginInner(context, logger, loginService, quickLoginUin, historyLoginList).then().catch(e => logger.logError(e));
-            loginListener.onLoginConnected = () => { };
         });
     }
     loginListener.onQRCodeGetPicture = ({ pngBase64QrcodeData, qrcodeUrl }) => {
-        WebUiDataRuntime.setQQLoginQrcodeURL(qrcodeUrl);
 
         const realBase64 = pngBase64QrcodeData.replace(/^data:image\/\w+;base64,/, '');
         const buffer = Buffer.from(realBase64, 'base64');
@@ -183,24 +177,6 @@ async function handleLogin(
     return await selfInfo;
 }
 async function handleLoginInner(context: { isLogined: boolean }, logger: LogWrapper, loginService: NodeIKernelLoginService, quickLoginUin: string | undefined, historyLoginList: LoginListItem[]) {
-    WebUiDataRuntime.setQuickLoginCall(async (uin: string) => {
-        return await new Promise((resolve) => {
-            if (uin) {
-                logger.log('正在快速登录 ', uin);
-                loginService.quickLoginWithUin(uin).then(res => {
-                    if (res.loginErrorInfo.errMsg) {
-                        resolve({ result: false, message: res.loginErrorInfo.errMsg });
-                    }
-                    resolve({ result: true, message: '' });
-                }).catch((e) => {
-                    logger.logError(e);
-                    resolve({ result: false, message: '快速登录发生错误' });
-                });
-            } else {
-                resolve({ result: false, message: '快速登录失败' });
-            }
-        });
-    });
     if (quickLoginUin) {
         if (historyLoginList.some(u => u.uin === quickLoginUin)) {
             logger.log('正在快速登录 ', quickLoginUin);
@@ -225,19 +201,8 @@ async function handleLoginInner(context: { isLogined: boolean }, logger: LogWrap
                 }`);
         }
         loginService.getQRCodePicture();
-        try {
-            await WebUiDataRuntime.runWebUiConfigQuickFunction();
-        } catch (error) {
-            logger.logError('WebUi 快速登录失败 执行失败', error);
-        }
     }
 
-    loginService.getLoginList().then((res) => {
-        // 遍历 res.LocalLoginInfoList[x].isQuickLogin是否可以 res.LocalLoginInfoList[x].uin 转为string 加入string[] 最后遍历完成调用WebUiDataRuntime.setQQQuickLoginList
-        const list = res.LocalLoginInfoList.filter((item) => item.isQuickLogin);
-        WebUiDataRuntime.setQQQuickLoginList(list.map((item) => item.uin.toString()));
-        WebUiDataRuntime.setQQNewLoginList(list);
-    });
 }
 
 async function initializeSession(
@@ -313,16 +278,6 @@ export async function NCoreInitShell() {
     const pathWrapper = new NapCatPathWrapper();
     const logger = new LogWrapper(pathWrapper.logsPath);
     handleUncaughtExceptions(logger);
-    await connectToNamedPipe(logger).catch(e => logger.logError('命名管道连接失败', e));
-    if (!process.env['NAPCAT_DISABLE_FFMPEG_DOWNLOAD']) {
-        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());
 
@@ -330,8 +285,6 @@ export async function NCoreInitShell() {
     o3Service.addO3MiscListener(new NodeIO3MiscListener());
 
     logger.log('[NapCat] [Core] NapCat.Core Version: ' + napCatVersion);
-    InitWebUi(logger, pathWrapper).then().catch(e => logger.logError(e));
-
     const engine = wrapper.NodeIQQNTWrapperEngine.get();
     const loginService = wrapper.NodeIKernelLoginService.get();
     const session = wrapper.NodeIQQNTWrapperSession.create();

src/shell/pipe.ts

@@ -1,74 +0,0 @@
-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);
-        }
-    });
-}

src/webui/Readme.md

@@ -1,3 +0,0 @@
-# The Path of NapCatQQ
-
-Tiny WebUi Backend for NapCatQQ

src/webui/index.ts

@@ -1,231 +0,0 @@
-/**
- * @file WebUI服务入口文件
- */
-
-import express from 'express';
-import { createServer } from 'http';
-import { createServer as createHttpsServer } from 'https';
-import { LogWrapper } from '@/common/log';
-import { NapCatPathWrapper } from '@/common/path';
-import { WebUiConfigWrapper } from '@webapi/helper/config';
-import { ALLRouter } from '@webapi/router';
-import { cors } from '@webapi/middleware/cors';
-import { createUrl } from '@webapi/utils/url';
-import { sendError } from '@webapi/utils/response';
-import { join } from 'node:path';
-import { terminalManager } from '@webapi/terminal/terminal_manager';
-import multer from 'multer'; // 引入multer用于错误捕获
-
-// 实例化Express
-const app = express();
-/**
- * 初始化并启动WebUI服务。
- * 该函数配置了Express服务器以支持JSON解析和静态文件服务，并监听6099端口。
- * 无需参数。
- * @returns {Promise<void>} 无返回值。
- */
-export let WebUiConfig: WebUiConfigWrapper;
-export let webUiPathWrapper: NapCatPathWrapper;
-const MAX_PORT_TRY = 100;
-import * as net from 'node:net';
-import { WebUiDataRuntime } from './src/helper/Data';
-import { existsSync, readFileSync } from 'node:fs';
-export let webUiRuntimePort = 6099;
-export async function InitPort(parsedConfig: WebUiConfigType): Promise<[string, number, string]> {
-    try {
-        await tryUseHost(parsedConfig.host);
-        const port = await tryUsePort(parsedConfig.port, parsedConfig.host);
-        return [parsedConfig.host, port, parsedConfig.token];
-    } catch (error) {
-        console.log('host或port不可用', error);
-        return ['', 0, ''];
-    }
-}
-async function checkCertificates(logger: LogWrapper): Promise<{ key: string, cert: string } | null> {
-    try {
-        const certPath = join(webUiPathWrapper.configPath, 'cert.pem');
-        const keyPath = join(webUiPathWrapper.configPath, 'key.pem');
-
-        if (existsSync(certPath) && existsSync(keyPath)) {
-            const cert = readFileSync(certPath, 'utf8');
-            const key = readFileSync(keyPath, 'utf8');
-            logger.log('[NapCat] [WebUi] 找到SSL证书，将启用HTTPS模式');
-            return { cert, key };
-        }
-        return null;
-    } catch (error) {
-        logger.log('[NapCat] [WebUi] 检查SSL证书时出错: ' + error);
-        return null;
-    }
-}
-export async function InitWebUi(logger: LogWrapper, pathWrapper: NapCatPathWrapper) {
-    webUiPathWrapper = pathWrapper;
-    WebUiConfig = new WebUiConfigWrapper();
-    const [host, port, token] = await InitPort(await WebUiConfig.GetWebUIConfig());
-    webUiRuntimePort = port;
-    if (port == 0) {
-        logger.log('[NapCat] [WebUi] Current WebUi is not run.');
-        return;
-    }
-    WebUiDataRuntime.setWebUiConfigQuickFunction(
-        async () => {
-            let autoLoginAccount = process.env['NAPCAT_QUICK_ACCOUNT'] || WebUiConfig.getAutoLoginAccount();
-            if (autoLoginAccount) {
-                try {
-                    const { result, message } = await WebUiDataRuntime.requestQuickLogin(autoLoginAccount);
-                    if (!result) {
-                        throw new Error(message);
-                    }
-                    console.log(`[NapCat] [WebUi] Auto login account: ${autoLoginAccount}`);
-                } catch (error) {
-                    console.log(`[NapCat] [WebUi] Auto login account failed.` + error);
-                }
-            }
-        });
-    // ------------注册中间件------------
-    // 使用express的json中间件
-    app.use(express.json());
-
-    // CORS中间件
-    // TODO:
-    app.use(cors);
-
-    // 如果是webui字体文件，挂载字体文件
-    app.use('/webui/fonts/AaCute.woff', async (_req, res, next) => {
-        const isFontExist = await WebUiConfig.CheckWebUIFontExist();
-        if (isFontExist) {
-            res.sendFile(WebUiConfig.GetWebUIFontPath());
-        } else {
-            next();
-        }
-    });
-
-    // 如果是自定义色彩，构建一个css文件
-    app.use('/files/theme.css', async (_req, res) => {
-        const colors = await WebUiConfig.GetTheme();
-
-        let css = ':root, .light, [data-theme="light"] {';
-        for (const key in colors.light) {
-            css += `${key}: ${colors.light[key]};`;
-        }
-        css += '}';
-        css += '.dark, [data-theme="dark"] {';
-        for (const key in colors.dark) {
-            css += `${key}: ${colors.dark[key]};`;
-        }
-        css += '}';
-
-        res.send(css);
-    });
-
-    // ------------中间件结束------------
-
-    // ------------挂载路由------------
-    // 挂载静态路由（前端），路径为 /webui
-    app.use('/webui', express.static(pathWrapper.staticPath));
-    // 初始化WebSocket服务器
-    const sslCerts = await checkCertificates(logger);
-    const isHttps = !!sslCerts;
-    let server = isHttps && sslCerts ? createHttpsServer(sslCerts, app) : createServer(app);
-    server.on('upgrade', (request, socket, head) => {
-        terminalManager.initialize(request, socket, head, logger);
-    });
-    // 挂载API接口
-    app.use('/api', ALLRouter);
-    // 所有剩下的请求都转到静态页面
-    const indexFile = join(pathWrapper.staticPath, 'index.html');
-
-    app.all(/\/webui\/(.*)/, (_req, res) => {
-        res.sendFile(indexFile);
-    });
-
-    // 初始服务（先放个首页）
-    app.all('/', (_req, res) => {
-        res.status(301).header('Location', '/webui').send();
-    });
-
-    // 错误处理中间件，捕获multer的错误
-    app.use((err: Error, _: express.Request, res: express.Response, next: express.NextFunction) => {
-        if (err instanceof multer.MulterError) {
-            return sendError(res, err.message, true);
-        }
-        next(err);
-    });
-
-    // 全局错误处理中间件（非multer错误）
-    app.use((_: Error, __: express.Request, res: express.Response, ___: express.NextFunction) => {
-        sendError(res, 'An unknown error occurred.', true);
-    });
-
-    // ------------启动服务------------
-    server.listen(port, host, async () => {
-        // 启动后打印出相关地址
-        let searchParams = { token: token };
-        if (host !== '' && host !== '0.0.0.0') {
-            logger.log(
-                `[NapCat] [WebUi] WebUi User Panel Url: ${createUrl(host, port.toString(), '/webui', searchParams)}`
-            );
-        }
-        logger.log(
-            `[NapCat] [WebUi] WebUi Local Panel Url: ${createUrl('127.0.0.1', port.toString(), '/webui', searchParams)}`
-        );
-    });
-    // ------------Over！------------
-}
-
-async function tryUseHost(host: string): Promise<string> {
-    return new Promise((resolve, reject) => {
-        try {
-            const server = net.createServer();
-            server.on('listening', () => {
-                server.close();
-                resolve(host);
-            });
-
-            server.on('error', (err: any) => {
-                if (err.code === 'EADDRNOTAVAIL') {
-                    reject(new Error('主机地址验证失败，可能为非本机地址'));
-                } else {
-                    reject(new Error(`遇到错误: ${err.code}`));
-                }
-            });
-
-            // 尝试监听 让系统随机分配一个端口
-            server.listen(0, host);
-        } catch (error) {
-            // 这里捕获到的错误应该是启动服务器时的同步错误
-            reject(new Error(`服务器启动时发生错误: ${error}`));
-        }
-    });
-}
-
-async function tryUsePort(port: number, host: string, tryCount: number = 0): Promise<number> {
-    return new Promise((resolve, reject) => {
-        try {
-            const server = net.createServer();
-            server.on('listening', () => {
-                server.close();
-                resolve(port);
-            });
-
-            server.on('error', (err: any) => {
-                if (err.code === 'EADDRINUSE') {
-                    if (tryCount < MAX_PORT_TRY) {
-                        // 使用循环代替递归
-                        resolve(tryUsePort(port + 1, host, tryCount + 1));
-                    } else {
-                        reject(new Error(`端口尝试失败，达到最大尝试次数: ${MAX_PORT_TRY}`));
-                    }
-                } else {
-                    reject(new Error(`遇到错误: ${err.code}`));
-                }
-            });
-
-            // 尝试监听端口
-            server.listen(port, host);
-        } catch (error) {
-            // 这里捕获到的错误应该是启动服务器时的同步错误
-            reject(new Error(`服务器启动时发生错误: ${error}`));
-        }
-    });
-}

src/webui/src/api/Auth.ts

@@ -1,116 +0,0 @@
-import { RequestHandler } from 'express';
-
-import { WebUiConfig } from '@/webui';
-
-import { AuthHelper } from '@webapi/helper/SignToken';
-import { WebUiDataRuntime } from '@webapi/helper/Data';
-import { sendSuccess, sendError } from '@webapi/utils/response';
-import { isEmpty } from '@webapi/utils/check';
-
-// 检查是否使用默认Token
-export const CheckDefaultTokenHandler: RequestHandler = async (_, res) => {
-    const webuiToken = await WebUiConfig.GetWebUIConfig();
-    if (webuiToken.token === 'napcat') {
-        return sendSuccess(res, true);
-    }
-    return sendSuccess(res, false);
-};
-
-// 登录
-export const LoginHandler: RequestHandler = async (req, res) => {
-    // 获取WebUI配置
-    const WebUiConfigData = await WebUiConfig.GetWebUIConfig();
-    // 获取请求体中的hash
-    const { hash } = req.body;
-    // 获取客户端IP
-    const clientIP = req.ip || req.socket.remoteAddress || '';
-
-    // 如果token为空，返回错误信息
-    if (isEmpty(hash)) {
-        return sendError(res, 'token is empty');
-    }
-    // 检查登录频率
-    if (!WebUiDataRuntime.checkLoginRate(clientIP, WebUiConfigData.loginRate)) {
-        return sendError(res, 'login rate limit');
-    }
-    //验证config.token hash是否等于token hash
-    if (!AuthHelper.comparePasswordHash(WebUiConfigData.token, hash)) {
-        return sendError(res, 'token is invalid');
-    }
-
-    // 签发凭证
-    const signCredential = Buffer.from(JSON.stringify(AuthHelper.signCredential(hash))).toString(
-        'base64'
-    );
-    // 返回成功信息
-    return sendSuccess(res, {
-        Credential: signCredential,
-    });
-};
-
-// 退出登录
-export const LogoutHandler: RequestHandler = async (req, res) => {
-    const authorization = req.headers.authorization;
-    try {
-        const CredentialBase64: string = authorization?.split(' ')[1] as string;
-        const Credential = JSON.parse(Buffer.from(CredentialBase64, 'base64').toString());
-        AuthHelper.revokeCredential(Credential);
-        return sendSuccess(res, 'Logged out successfully');
-    } catch (e) {
-        return sendError(res, 'Logout failed');
-    }
-};
-
-// 检查登录状态
-export const checkHandler: RequestHandler = async (req, res) => {
-    // 获取WebUI配置
-    const WebUiConfigData = await WebUiConfig.GetWebUIConfig();
-    // 获取请求头中的Authorization
-    const authorization = req.headers.authorization;
-    // 检查凭证
-    try {
-        // 从Authorization中获取凭证
-        const CredentialBase64: string = authorization?.split(' ')[1] as string;
-        // 解析凭证
-        const Credential = JSON.parse(Buffer.from(CredentialBase64, 'base64').toString());
-
-        // 检查凭证是否已被注销
-        if (AuthHelper.isCredentialRevoked(Credential)) {
-            return sendError(res, 'Token has been revoked');
-        }
-
-        // 验证凭证是否在一小时内有效
-        const valid = AuthHelper.validateCredentialWithinOneHour(WebUiConfigData.token, Credential);
-        // 返回成功信息
-        if (valid) return sendSuccess(res, null);
-        // 返回错误信息
-        return sendError(res, 'Authorization Failed');
-    } catch (e) {
-        // 返回错误信息
-        return sendError(res, 'Authorization Failed');
-    }
-};
-
-// 修改密码（token）
-export const UpdateTokenHandler: RequestHandler = async (req, res) => {
-    const { oldToken, newToken } = req.body;
-    const authorization = req.headers.authorization;
-
-    if (isEmpty(oldToken) || isEmpty(newToken)) {
-        return sendError(res, 'oldToken or newToken is empty');
-    }
-
-    try {
-        // 注销当前的Token
-        if (authorization) {
-            const CredentialBase64: string = authorization.split(' ')[1] as string;
-            const Credential = JSON.parse(Buffer.from(CredentialBase64, 'base64').toString());
-            AuthHelper.revokeCredential(Credential);
-        }
-
-        await WebUiConfig.UpdateToken(oldToken, newToken);
-        return sendSuccess(res, 'Token updated successfully');
-    } catch (e: any) {
-        return sendError(res, `Failed to update token: ${e.message}`);
-    }
-};

src/webui/src/api/BaseInfo.ts

@@ -1,26 +0,0 @@
-import { RequestHandler } from 'express';
-import { WebUiDataRuntime } from '@webapi/helper/Data';
-
-import { sendSuccess } from '@webapi/utils/response';
-import { WebUiConfig } from '@/webui';
-
-export const PackageInfoHandler: RequestHandler = (_, res) => {
-    const data = WebUiDataRuntime.getPackageJson();
-    sendSuccess(res, data);
-};
-
-export const QQVersionHandler: RequestHandler = (_, res) => {
-    const data = WebUiDataRuntime.getQQVersion();
-    sendSuccess(res, data);
-};
-
-export const GetThemeConfigHandler: RequestHandler = async (_, res) => {
-    const data = await WebUiConfig.GetTheme();
-    sendSuccess(res, data);
-};
-
-export const SetThemeConfigHandler: RequestHandler = async (req, res) => {
-    const { theme } = req.body;
-    await WebUiConfig.UpdateTheme(theme);
-    sendSuccess(res, { message: '更新成功' });
-};

src/webui/src/api/File.ts

@@ -1,399 +0,0 @@
-import type { RequestHandler } from 'express';
-import { sendError, sendSuccess } from '../utils/response';
-import fsProm from 'fs/promises';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import compressing from 'compressing';
-import { PassThrough } from 'stream';
-import multer from 'multer';
-import webUIFontUploader from '../uploader/webui_font';
-import diskUploader from '../uploader/disk';
-import { WebUiConfig } from '@/webui';
-
-const isWindows = os.platform() === 'win32';
-
-// 获取系统根目录列表（Windows返回盘符列表，其他系统返回['/']）
-const getRootDirs = async (): Promise<string[]> => {
-    if (!isWindows) return ['/'];
-
-    // Windows 驱动器字母 (A-Z)
-    const drives: string[] = [];
-    for (let i = 65; i <= 90; i++) {
-        const driveLetter = String.fromCharCode(i);
-        try {
-            await fsProm.access(`${driveLetter}:\\`);
-            drives.push(`${driveLetter}:`);
-        } catch {
-            // 如果驱动器不存在或无法访问，跳过
-            continue;
-        }
-    }
-    return drives.length > 0 ? drives : ['C:'];
-};
-
-// 规范化路径
-const normalizePath = (inputPath: string): string => {
-    if (!inputPath) return isWindows ? 'C:\\' : '/';
-    // 如果是Windows且输入为纯盘符（可能带或不带斜杠），统一返回 "X:\"
-    if (isWindows && /^[A-Z]:[\\/]*$/i.test(inputPath)) {
-        return inputPath.slice(0, 2) + '\\';
-    }
-    return path.normalize(inputPath);
-};
-
-interface FileInfo {
-    name: string;
-    isDirectory: boolean;
-    size: number;
-    mtime: Date;
-}
-
-// 添加系统文件黑名单
-const SYSTEM_FILES = new Set(['pagefile.sys', 'swapfile.sys', 'hiberfil.sys', 'System Volume Information']);
-
-// 检查同类型的文件或目录是否存在
-const checkSameTypeExists = async (pathToCheck: string, isDirectory: boolean): Promise<boolean> => {
-    try {
-        const stat = await fsProm.stat(pathToCheck);
-        // 只有当类型相同时才认为是冲突
-        return stat.isDirectory() === isDirectory;
-    } catch {
-        return false;
-    }
-};
-
-// 获取目录内容
-export const ListFilesHandler: RequestHandler = async (req, res) => {
-    try {
-        const requestPath = (req.query['path'] as string) || (isWindows ? 'C:\\' : '/');
-        const normalizedPath = normalizePath(requestPath);
-        const onlyDirectory = req.query['onlyDirectory'] === 'true';
-
-        // 如果是根路径且在Windows系统上，返回盘符列表
-        if (isWindows && (!requestPath || requestPath === '/' || requestPath === '\\')) {
-            const drives = await getRootDirs();
-            const driveInfos: FileInfo[] = await Promise.all(
-                drives.map(async (drive) => {
-                    try {
-                        const stat = await fsProm.stat(`${drive}\\`);
-                        return {
-                            name: drive,
-                            isDirectory: true,
-                            size: 0,
-                            mtime: stat.mtime,
-                        };
-                    } catch {
-                        return {
-                            name: drive,
-                            isDirectory: true,
-                            size: 0,
-                            mtime: new Date(),
-                        };
-                    }
-                })
-            );
-            return sendSuccess(res, driveInfos);
-        }
-
-        const files = await fsProm.readdir(normalizedPath);
-        let fileInfos: FileInfo[] = [];
-
-        for (const file of files) {
-            // 跳过系统文件
-            if (SYSTEM_FILES.has(file)) continue;
-
-            try {
-                const fullPath = path.join(normalizedPath, file);
-                const stat = await fsProm.stat(fullPath);
-                fileInfos.push({
-                    name: file,
-                    isDirectory: stat.isDirectory(),
-                    size: stat.size,
-                    mtime: stat.mtime,
-                });
-            } catch (error) {
-                // 忽略无法访问的文件
-                // console.warn(`无法访问文件 ${file}:`, error);
-                continue;
-            }
-        }
-
-        // 如果请求参数 onlyDirectory 为 true，则只返回目录信息
-        if (onlyDirectory) {
-            fileInfos = fileInfos.filter((info) => info.isDirectory);
-        }
-
-        return sendSuccess(res, fileInfos);
-    } catch (error) {
-        console.error('读取目录失败:', error);
-        return sendError(res, '读取目录失败');
-    }
-};
-
-// 创建目录
-export const CreateDirHandler: RequestHandler = async (req, res) => {
-    try {
-        const { path: dirPath } = req.body;
-        const normalizedPath = normalizePath(dirPath);
-
-        // 检查是否已存在同类型（目录）
-        if (await checkSameTypeExists(normalizedPath, true)) {
-            return sendError(res, '同名目录已存在');
-        }
-
-        await fsProm.mkdir(normalizedPath, { recursive: true });
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '创建目录失败');
-    }
-};
-
-// 删除文件/目录
-export const DeleteHandler: RequestHandler = async (req, res) => {
-    try {
-        const { path: targetPath } = req.body;
-        const normalizedPath = normalizePath(targetPath);
-        const stat = await fsProm.stat(normalizedPath);
-        if (stat.isDirectory()) {
-            await fsProm.rm(normalizedPath, { recursive: true });
-        } else {
-            await fsProm.unlink(normalizedPath);
-        }
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '删除失败');
-    }
-};
-
-// 批量删除文件/目录
-export const BatchDeleteHandler: RequestHandler = async (req, res) => {
-    try {
-        const { paths } = req.body;
-        for (const targetPath of paths) {
-            const normalizedPath = normalizePath(targetPath);
-            const stat = await fsProm.stat(normalizedPath);
-            if (stat.isDirectory()) {
-                await fsProm.rm(normalizedPath, { recursive: true });
-            } else {
-                await fsProm.unlink(normalizedPath);
-            }
-        }
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '批量删除失败');
-    }
-};
-
-// 读取文件内容
-export const ReadFileHandler: RequestHandler = async (req, res) => {
-    try {
-        const filePath = normalizePath(req.query['path'] as string);
-        const content = await fsProm.readFile(filePath, 'utf-8');
-        return sendSuccess(res, content);
-    } catch (error) {
-        return sendError(res, '读取文件失败');
-    }
-};
-
-// 写入文件内容
-export const WriteFileHandler: RequestHandler = async (req, res) => {
-    try {
-        const { path: filePath, content } = req.body;
-        const normalizedPath = normalizePath(filePath);
-        await fsProm.writeFile(normalizedPath, content, 'utf-8');
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '写入文件失败');
-    }
-};
-
-// 创建新文件
-export const CreateFileHandler: RequestHandler = async (req, res) => {
-    try {
-        const { path: filePath } = req.body;
-        const normalizedPath = normalizePath(filePath);
-
-        // 检查是否已存在同类型（文件）
-        if (await checkSameTypeExists(normalizedPath, false)) {
-            return sendError(res, '同名文件已存在');
-        }
-
-        await fsProm.writeFile(normalizedPath, '', 'utf-8');
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '创建文件失败');
-    }
-};
-
-// 重命名文件/目录
-export const RenameHandler: RequestHandler = async (req, res) => {
-    try {
-        const { oldPath, newPath } = req.body;
-        const normalizedOldPath = normalizePath(oldPath);
-        const normalizedNewPath = normalizePath(newPath);
-        await fsProm.rename(normalizedOldPath, normalizedNewPath);
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '重命名失败');
-    }
-};
-
-// 移动文件/目录
-export const MoveHandler: RequestHandler = async (req, res) => {
-    try {
-        const { sourcePath, targetPath } = req.body;
-        const normalizedSourcePath = normalizePath(sourcePath);
-        const normalizedTargetPath = normalizePath(targetPath);
-        await fsProm.rename(normalizedSourcePath, normalizedTargetPath);
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '移动失败');
-    }
-};
-
-// 批量移动
-export const BatchMoveHandler: RequestHandler = async (req, res) => {
-    try {
-        const { items } = req.body;
-        for (const { sourcePath, targetPath } of items) {
-            const normalizedSourcePath = normalizePath(sourcePath);
-            const normalizedTargetPath = normalizePath(targetPath);
-            await fsProm.rename(normalizedSourcePath, normalizedTargetPath);
-        }
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '批量移动失败');
-    }
-};
-
-// 新增：文件下载处理方法（注意流式传输，不将整个文件读入内存）
-export const DownloadHandler: RequestHandler = async (req, res) => {
-    try {
-        const filePath = normalizePath(req.query['path'] as string);
-        if (!filePath) {
-            return sendError(res, '参数错误');
-        }
-
-        const stat = await fsProm.stat(filePath);
-
-        res.setHeader('Content-Type', 'application/octet-stream');
-        let filename = path.basename(filePath);
-        if (stat.isDirectory()) {
-            filename = path.basename(filePath) + '.zip';
-            res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`);
-            const zipStream = new PassThrough();
-            compressing.zip.compressDir(filePath, zipStream as unknown as fs.WriteStream).catch((err) => {
-                console.error('压缩目录失败:', err);
-                res.end();
-            });
-            zipStream.pipe(res);
-            return;
-        }
-        res.setHeader('Content-Length', stat.size);
-        res.setHeader('Content-Disposition', `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`);
-        const stream = fs.createReadStream(filePath);
-        stream.pipe(res);
-    } catch (error) {
-        return sendError(res, '下载失败');
-    }
-};
-
-// 批量下载：将多个文件/目录打包为 zip 文件下载
-export const BatchDownloadHandler: RequestHandler = async (req, res) => {
-    try {
-        const { paths } = req.body as { paths: string[] };
-        if (!paths || !Array.isArray(paths) || paths.length === 0) {
-            return sendError(res, '参数错误');
-        }
-        res.setHeader('Content-Type', 'application/octet-stream');
-        res.setHeader('Content-Disposition', 'attachment; filename=files.zip');
-
-        const zipStream = new compressing.zip.Stream();
-        // 修改：根据文件类型设置 relativePath
-        for (const filePath of paths) {
-            const normalizedPath = normalizePath(filePath);
-            const stat = await fsProm.stat(normalizedPath);
-            if (stat.isDirectory()) {
-                zipStream.addEntry(normalizedPath, { relativePath: '' });
-            } else {
-                zipStream.addEntry(normalizedPath, { relativePath: path.basename(normalizedPath) });
-            }
-        }
-        zipStream.pipe(res);
-        res.on('finish', () => {
-            zipStream.destroy();
-        });
-    } catch (error) {
-        return sendError(res, '下载失败');
-    }
-};
-
-// 修改上传处理方法
-export const UploadHandler: RequestHandler = async (req, res) => {
-    try {
-        await diskUploader(req, res);
-        return sendSuccess(res, true, '文件上传成功', true);
-    } catch (error) {
-        let errorMessage = '文件上传失败';
-
-        if (error instanceof multer.MulterError) {
-            switch (error.code) {
-                case 'LIMIT_FILE_SIZE':
-                    errorMessage = '文件大小超过限制（40MB）';
-                    break;
-                case 'LIMIT_UNEXPECTED_FILE':
-                    errorMessage = '无效的文件上传字段';
-                    break;
-                default:
-                    errorMessage = `上传错误: ${error.message}`;
-            }
-        } else if (error instanceof Error) {
-            errorMessage = error.message;
-        }
-        return sendError(res, errorMessage, true);
-    }
-};
-
-// 上传WebUI字体文件处理方法
-export const UploadWebUIFontHandler: RequestHandler = async (req, res) => {
-    try {
-        await webUIFontUploader(req, res);
-        return sendSuccess(res, true, '字体文件上传成功', true);
-    } catch (error) {
-        let errorMessage = '字体文件上传失败';
-
-        if (error instanceof multer.MulterError) {
-            switch (error.code) {
-                case 'LIMIT_FILE_SIZE':
-                    errorMessage = '字体文件大小超过限制（40MB）';
-                    break;
-                case 'LIMIT_UNEXPECTED_FILE':
-                    errorMessage = '无效的文件上传字段';
-                    break;
-                default:
-                    errorMessage = `上传错误: ${error.message}`;
-            }
-        } else if (error instanceof Error) {
-            errorMessage = error.message;
-        }
-        return sendError(res, errorMessage, true);
-    }
-};
-
-// 删除WebUI字体文件处理方法
-export const DeleteWebUIFontHandler: RequestHandler = async (_req, res) => {
-    try {
-        const fontPath = WebUiConfig.GetWebUIFontPath();
-        const exists = await WebUiConfig.CheckWebUIFontExist();
-
-        if (!exists) {
-            return sendSuccess(res, true);
-        }
-
-        await fsProm.unlink(fontPath);
-        return sendSuccess(res, true);
-    } catch (error) {
-        return sendError(res, '删除字体文件失败');
-    }
-};

src/webui/src/api/Log.ts

@@ -1,72 +0,0 @@
-import type { RequestHandler } from 'express';
-import { sendError, sendSuccess } from '../utils/response';
-import { logSubscription } from '@/common/log';
-import { terminalManager } from '../terminal/terminal_manager';
-import { WebUiConfig } from '@/webui';
-// 判断是否是 macos
-const isMacOS = process.platform === 'darwin';
-// 日志记录
-export const LogHandler: RequestHandler = async (req, res) => {
-    const filename = req.query['id'];
-    if (!filename || typeof filename !== 'string') {
-        return sendError(res, 'ID不能为空');
-    }
-
-    if (filename.includes('..')) {
-        return sendError(res, 'ID不合法');
-    }
-    const logContent = await WebUiConfig.GetLogContent(filename);
-    return sendSuccess(res, logContent);
-};
-
-// 日志列表
-export const LogListHandler: RequestHandler = async (_, res) => {
-    const logList = await WebUiConfig.GetLogsList();
-    return sendSuccess(res, logList);
-};
-
-// 实时日志（SSE）
-export const LogRealTimeHandler: RequestHandler = async (req, res) => {
-    res.setHeader('Content-Type', 'text/event-stream');
-    res.setHeader('Connection', 'keep-alive');
-    const listener = (log: string) => {
-        try {
-            res.write(`data: ${log}\n\n`);
-        } catch (error) {
-            console.error('向客户端写入日志数据时出错:', error);
-        }
-    };
-    logSubscription.subscribe(listener);
-    req.on('close', () => {
-        logSubscription.unsubscribe(listener);
-    });
-};
-
-// 终端相关处理器
-export const CreateTerminalHandler: RequestHandler = async (req, res) => {
-    if (isMacOS) {
-        return sendError(res, 'MacOS不支持终端');
-    }
-    try {
-        const { cols, rows } = req.body;
-        const { id } = terminalManager.createTerminal(cols, rows);
-        return sendSuccess(res, { id });
-    } catch (error) {
-        console.error('Failed to create terminal:', error);
-        return sendError(res, '创建终端失败');
-    }
-};
-
-export const GetTerminalListHandler: RequestHandler = (_, res) => {
-    const list = terminalManager.getTerminalList();
-    return sendSuccess(res, list);
-};
-
-export const CloseTerminalHandler: RequestHandler = (req, res) => {
-    const id = req.params['id'];
-    if (!id) {
-        return sendError(res, 'ID不能为空');
-    }
-    terminalManager.closeTerminal(id);
-    return sendSuccess(res, {});
-};

src/webui/src/api/OB11Config.ts

@@ -1,60 +0,0 @@
-import { RequestHandler } from 'express';
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { loadConfig, OneBotConfig } from '@/onebot/config/config';
-import { webUiPathWrapper } from '@/webui';
-import { WebUiDataRuntime } from '@webapi/helper/Data';
-import { sendError, sendSuccess } from '@webapi/utils/response';
-import { isEmpty } from '@webapi/utils/check';
-import json5 from 'json5';
-
-// 获取OneBot11配置
-export const OB11GetConfigHandler: RequestHandler = (_, res) => {
-    // 获取QQ登录状态
-    const isLogin = WebUiDataRuntime.getQQLoginStatus();
-    // 如果未登录，返回错误
-    if (!isLogin) {
-        return sendError(res, 'Not Login');
-    }
-    // 获取登录的QQ号
-    const uin = WebUiDataRuntime.getQQLoginUin();
-    // 读取配置文件路径
-    const configFilePath = resolve(webUiPathWrapper.configPath, `./onebot11_${uin}.json`);
-    // 尝试解析配置文件
-    try {
-        // 读取配置文件内容
-        const configFileContent = existsSync(configFilePath)
-            ? readFileSync(configFilePath).toString()
-            : readFileSync(resolve(webUiPathWrapper.configPath, './onebot11.json')).toString();
-        // 解析配置文件并加载配置
-        const data = loadConfig(json5.parse(configFileContent)) as OneBotConfig;
-        // 返回配置文件
-        return sendSuccess(res, data);
-    } catch (e) {
-        return sendError(res, 'Config Get Error');
-    }
-};
-
-// 写入OneBot11配置
-export const OB11SetConfigHandler: RequestHandler = async (req, res) => {
-    // 获取QQ登录状态
-    const isLogin = WebUiDataRuntime.getQQLoginStatus();
-    // 如果未登录，返回错误
-    if (!isLogin) {
-        return sendError(res, 'Not Login');
-    }
-    // 如果配置为空，返回错误
-    if (isEmpty(req.body.config)) {
-        return sendError(res, 'config is empty');
-    }
-    // 写入配置
-    try {
-        // 解析并加载配置
-        const config = loadConfig(json5.parse(req.body.config)) as OneBotConfig;
-        // 写入配置
-        await WebUiDataRuntime.setOB11Config(config);
-        return sendSuccess(res, null);
-    } catch (e) {
-        return sendError(res, 'Error: ' + e);
-    }
-};

src/webui/src/api/Proxy.ts

@@ -1,14 +0,0 @@
-import { RequestHandler } from 'express';
-import { RequestUtil } from '@/common/request';
-import { sendError, sendSuccess } from '../utils/response';
-
-export const GetProxyHandler: RequestHandler = async (req, res) => {
-    let { url } = req.query;
-    if (url && typeof url === 'string') {
-        url = decodeURIComponent(url);
-        const responseText = await RequestUtil.HttpGetText(url);
-        return sendSuccess(res, responseText);
-    } else {
-        return sendError(res, 'url参数不合法');
-    }
-};

src/webui/src/api/QQLogin.ts

@@ -1,90 +0,0 @@
-import { RequestHandler } from 'express';
-
-import { WebUiDataRuntime } from '@webapi/helper/Data';
-import { isEmpty } from '@webapi/utils/check';
-import { sendError, sendSuccess } from '@webapi/utils/response';
-import { WebUiConfig } from '@/webui';
-
-// 获取QQ登录二维码
-export const QQGetQRcodeHandler: RequestHandler = async (_, res) => {
-    // 判断是否已经登录
-    if (WebUiDataRuntime.getQQLoginStatus()) {
-        // 已经登录
-        return sendError(res, 'QQ Is Logined');
-    }
-    // 获取二维码
-    const qrcodeUrl = WebUiDataRuntime.getQQLoginQrcodeURL();
-    // 判断二维码是否为空
-    if (isEmpty(qrcodeUrl)) {
-        return sendError(res, 'QRCode Get Error');
-    }
-    // 返回二维码URL
-    const data = {
-        qrcode: qrcodeUrl,
-    };
-    return sendSuccess(res, data);
-};
-
-// 获取QQ登录状态
-export const QQCheckLoginStatusHandler: RequestHandler = async (_, res) => {
-    const data = {
-        isLogin: WebUiDataRuntime.getQQLoginStatus(),
-        qrcodeurl: WebUiDataRuntime.getQQLoginQrcodeURL(),
-    };
-    return sendSuccess(res, data);
-};
-
-// 快速登录
-export const QQSetQuickLoginHandler: RequestHandler = async (req, res) => {
-    // 获取QQ号
-    const { uin } = req.body;
-    // 判断是否已经登录
-    const isLogin = WebUiDataRuntime.getQQLoginStatus();
-    if (isLogin) {
-        return sendError(res, 'QQ Is Logined');
-    }
-    // 判断QQ号是否为空
-    if (isEmpty(uin)) {
-        return sendError(res, 'uin is empty');
-    }
-
-    // 获取快速登录状态
-    const { result, message } = await WebUiDataRuntime.requestQuickLogin(uin);
-    if (!result) {
-        return sendError(res, message);
-    }
-    //本来应该验证 但是http不宜这么搞 建议前端验证
-    //isLogin = WebUiDataRuntime.getQQLoginStatus();
-    return sendSuccess(res, null);
-};
-
-// 获取快速登录列表
-export const QQGetQuickLoginListHandler: RequestHandler = async (_, res) => {
-    const quickLoginList = WebUiDataRuntime.getQQQuickLoginList();
-    return sendSuccess(res, quickLoginList);
-};
-
-// 获取快速登录列表（新）
-export const QQGetLoginListNewHandler: RequestHandler = async (_, res) => {
-    const newLoginList = WebUiDataRuntime.getQQNewLoginList();
-    return sendSuccess(res, newLoginList);
-};
-
-// 获取登录的QQ的信息
-export const getQQLoginInfoHandler: RequestHandler = async (_, res) => {
-    const data = WebUiDataRuntime.getQQLoginInfo();
-    return sendSuccess(res, data);
-};
-
-// 获取自动登录QQ账号
-export const getAutoLoginAccountHandler: RequestHandler = async (_, res) => {
-    const data = WebUiConfig.getAutoLoginAccount();
-    return sendSuccess(res, data);
-};
-
-// 设置自动登录QQ账号
-export const setAutoLoginAccountHandler: RequestHandler = async (req, res) => {
-    const { uin } = req.body;
-    await WebUiConfig.UpdateAutoLoginAccount(uin);
-    return sendSuccess(res, null);
-};

src/webui/src/api/Status.ts

@@ -1,19 +0,0 @@
-import { RequestHandler } from 'express';
-import { SystemStatus, statusHelperSubscription } from '@/core/helper/status';
-
-export const StatusRealTimeHandler: RequestHandler = async (req, res) => {
-    res.setHeader('Content-Type', 'text/event-stream');
-    res.setHeader('Connection', 'keep-alive');
-    const sendStatus = (status: SystemStatus) => {
-        try{
-            res.write(`data: ${JSON.stringify(status)}\n\n`);
-        } catch (e) {
-            console.error(`An error occurred when writing sendStatus data to client: ${e}`);
-        }
-    };
-    statusHelperSubscription.on('statusUpdate', sendStatus);
-    req.on('close', () => {
-        statusHelperSubscription.off('statusUpdate', sendStatus);
-        res.end();
-    });
-};

src/webui/src/const/status.ts

@@ -1,13 +0,0 @@
-export enum HttpStatusCode {
-    OK = 200,
-    BadRequest = 400,
-    Unauthorized = 401,
-    Forbidden = 403,
-    NotFound = 404,
-    InternalServerError = 500,
-}
-
-export enum ResponseCode {
-    Success = 0,
-    Error = -1,
-}

src/webui/src/helper/Data.ts

@@ -1,131 +0,0 @@
-import type { LoginRuntimeType } from '../types/data';
-import packageJson from '../../../../package.json';
-import store from '@/common/store';
-
-const LoginRuntime: LoginRuntimeType = {
-    LoginCurrentTime: Date.now(),
-    LoginCurrentRate: 0,
-    QQLoginStatus: false, //已实现 但太傻了 得去那边注册个回调刷新
-    QQQRCodeURL: '',
-    QQLoginUin: '',
-    QQLoginInfo: {
-        uid: '',
-        uin: '',
-        nick: '',
-    },
-    QQVersion: 'unknown',
-    NapCatHelper: {
-        onOB11ConfigChanged: async () => {
-            return;
-        },
-        onQuickLoginRequested: async () => {
-            return { result: false, message: '' };
-        },
-        QQLoginList: [],
-        NewQQLoginList: [],
-    },
-    packageJson: packageJson,
-    WebUiConfigQuickFunction: async () => {
-        return;
-    }
-};
-
-export const WebUiDataRuntime = {
-    checkLoginRate(ip: string, RateLimit: number): boolean {
-        const key = `login_rate:${ip}`;
-        const count = store.get<number>(key) || 0;
-
-        if (count === 0) {
-            // 第一次访问，设置计数器为1，并设置60秒过期
-            store.set(key, 1, 60);
-            return true;
-        }
-
-        if (count >= RateLimit) {
-            return false;
-        }
-
-        store.incr(key);
-        return true;
-    },
-
-    getQQLoginStatus(): LoginRuntimeType['QQLoginStatus'] {
-        return LoginRuntime.QQLoginStatus;
-    },
-
-    setQQLoginStatus(status: LoginRuntimeType['QQLoginStatus']): void {
-        LoginRuntime.QQLoginStatus = status;
-    },
-
-    setQQLoginQrcodeURL(url: LoginRuntimeType['QQQRCodeURL']): void {
-        LoginRuntime.QQQRCodeURL = url;
-    },
-
-    getQQLoginQrcodeURL(): LoginRuntimeType['QQQRCodeURL'] {
-        return LoginRuntime.QQQRCodeURL;
-    },
-
-    setQQLoginInfo(info: LoginRuntimeType['QQLoginInfo']): void {
-        LoginRuntime.QQLoginInfo = info;
-        LoginRuntime.QQLoginUin = info.uin.toString();
-    },
-
-    getQQLoginInfo(): LoginRuntimeType['QQLoginInfo'] {
-        return LoginRuntime.QQLoginInfo;
-    },
-
-    getQQLoginUin(): LoginRuntimeType['QQLoginUin'] {
-        return LoginRuntime.QQLoginUin;
-    },
-
-    getQQQuickLoginList(): LoginRuntimeType['NapCatHelper']['QQLoginList'] {
-        return LoginRuntime.NapCatHelper.QQLoginList;
-    },
-
-    setQQQuickLoginList(list: LoginRuntimeType['NapCatHelper']['QQLoginList']): void {
-        LoginRuntime.NapCatHelper.QQLoginList = list;
-    },
-
-    getQQNewLoginList(): LoginRuntimeType['NapCatHelper']['NewQQLoginList'] {
-        return LoginRuntime.NapCatHelper.NewQQLoginList;
-    },
-
-    setQQNewLoginList(list: LoginRuntimeType['NapCatHelper']['NewQQLoginList']): void {
-        LoginRuntime.NapCatHelper.NewQQLoginList = list;
-    },
-
-    setQuickLoginCall(func: LoginRuntimeType['NapCatHelper']['onQuickLoginRequested']): void {
-        LoginRuntime.NapCatHelper.onQuickLoginRequested = func;
-    },
-
-    requestQuickLogin: function (uin) {
-        return LoginRuntime.NapCatHelper.onQuickLoginRequested(uin);
-    } as LoginRuntimeType['NapCatHelper']['onQuickLoginRequested'],
-
-    setOnOB11ConfigChanged(func: LoginRuntimeType['NapCatHelper']['onOB11ConfigChanged']): void {
-        LoginRuntime.NapCatHelper.onOB11ConfigChanged = func;
-    },
-
-    setOB11Config: function (ob11) {
-        return LoginRuntime.NapCatHelper.onOB11ConfigChanged(ob11);
-    } as LoginRuntimeType['NapCatHelper']['onOB11ConfigChanged'],
-
-    getPackageJson() {
-        return LoginRuntime.packageJson;
-    },
-
-    setQQVersion(version: string) {
-        LoginRuntime.QQVersion = version;
-    },
-
-    getQQVersion() {
-        return LoginRuntime.QQVersion;
-    },
-
-    setWebUiConfigQuickFunction(func: LoginRuntimeType['WebUiConfigQuickFunction']): void {
-        LoginRuntime.WebUiConfigQuickFunction = func;
-    },
-    runWebUiConfigQuickFunction: async function () {
-        await LoginRuntime.WebUiConfigQuickFunction();
-    }
-};

src/webui/src/helper/SignToken.ts

@@ -1,106 +0,0 @@
-import crypto from 'crypto';
-import store from '@/common/store';
-export class AuthHelper {
-    private static readonly secretKey = Math.random().toString(36).slice(2);
-
-    /**
-     * 签名凭证方法。
-     * @param hash 待签名的凭证字符串。
-     * @returns 签名后的凭证对象。
-     */
-    public static signCredential(hash: string): WebUiCredentialJson {
-        const innerJson: WebUiCredentialInnerJson = {
-            CreatedTime: Date.now(),
-            HashEncoded: hash,
-        };
-        const jsonString = JSON.stringify(innerJson);
-        const hmac = crypto.createHmac('sha256', AuthHelper.secretKey).update(jsonString, 'utf8').digest('hex');
-        return { Data: innerJson, Hmac: hmac };
-    }
-
-    /**
-     * 检查凭证是否被篡改的方法。
-     * @param credentialJson 凭证的JSON对象。
-     * @returns 布尔值，表示凭证是否有效。
-     */
-    public static checkCredential(credentialJson: WebUiCredentialJson): boolean {
-        try {
-            const jsonString = JSON.stringify(credentialJson.Data);
-            const calculatedHmac = crypto
-                .createHmac('sha256', AuthHelper.secretKey)
-                .update(jsonString, 'utf8')
-                .digest('hex');
-            return calculatedHmac === credentialJson.Hmac;
-        } catch (error) {
-            return false;
-        }
-    }
-
-    /**
-     * 验证凭证在1小时内有效且token与原始token相同。
-     * @param token 待验证的原始token。
-     * @param credentialJson 已签名的凭证JSON对象。
-     * @returns 布尔值，表示凭证是否有效且token匹配。
-     */
-    public static validateCredentialWithinOneHour(token: string, credentialJson: WebUiCredentialJson): boolean {
-        // 首先检查凭证是否被篡改
-        const isValid = AuthHelper.checkCredential(credentialJson);
-        if (!isValid) {
-            return false;
-        }
-
-        // 检查凭证是否在黑名单中
-        if (AuthHelper.isCredentialRevoked(credentialJson)) {
-            return false;
-        }
-
-        const currentTime = Date.now() / 1000;
-        const createdTime = credentialJson.Data.CreatedTime;
-        const timeDifference = currentTime - createdTime;
-        return timeDifference <= 3600 && credentialJson.Data.HashEncoded === AuthHelper.generatePasswordHash(token);
-    }
-
-    /**
-     * 注销指定的Token凭证
-     * @param credentialJson 凭证JSON对象
-     * @returns void
-     */
-    public static revokeCredential(credentialJson: WebUiCredentialJson): void {
-        const jsonString = JSON.stringify(credentialJson.Data);
-        const hmac = crypto.createHmac('sha256', AuthHelper.secretKey).update(jsonString, 'utf8').digest('hex');
-
-        // 将已注销的凭证添加到黑名单中，有效期1小时
-        store.set(`revoked:${hmac}`, true, 3600);
-    }
-
-    /**
-     * 检查凭证是否已被注销
-     * @param credentialJson 凭证JSON对象
-     * @returns 布尔值，表示凭证是否已被注销
-     */
-    public static isCredentialRevoked(credentialJson: WebUiCredentialJson): boolean {
-        const jsonString = JSON.stringify(credentialJson.Data);
-        const hmac = crypto.createHmac('sha256', AuthHelper.secretKey).update(jsonString, 'utf8').digest('hex');
-
-        return store.exists(`revoked:${hmac}`) > 0;
-    }
-
-    /**
-     * 生成密码Hash
-     * @param password 密码
-     * @returns 生成的Hash值
-     */
-    public static generatePasswordHash(password: string): string {
-        return crypto.createHash('sha256').update(password + '.napcat').digest().toString('hex')
-    }
-
-    /**
-     * 对比密码和Hash值
-     * @param password 密码
-     * @param hash Hash值
-     * @returns 布尔值，表示密码是否匹配Hash值
-     */
-    public static comparePasswordHash(password: string, hash: string): boolean {
-        return this.generatePasswordHash(password) === hash;
-    }
-}

src/webui/src/helper/config.ts

@@ -1,179 +0,0 @@
-import { webUiPathWrapper } from '@/webui';
-import { Type, Static } from '@sinclair/typebox';
-import Ajv from 'ajv';
-import fs, { constants } from 'node:fs/promises';
-
-import { resolve } from 'node:path';
-
-import { deepMerge } from '../utils/object';
-import { themeType } from '../types/theme';
-
-// 限制尝试端口的次数，避免死循环
-
-// 定义配置的类型
-const WebUiConfigSchema = Type.Object({
-    host: Type.String({ default: '0.0.0.0' }),
-    port: Type.Number({ default: 6099 }),
-    token: Type.String({ default: 'napcat' }),
-    loginRate: Type.Number({ default: 10 }),
-    autoLoginAccount: Type.String({ default: '' }),
-    theme: themeType,
-});
-
-export type WebUiConfigType = Static<typeof WebUiConfigSchema>;
-
-// 读取当前目录下名为 webui.json 的配置文件，如果不存在则创建初始化配置文件
-export class WebUiConfigWrapper {
-    WebUiConfigData: WebUiConfigType | undefined = undefined;
-
-    private validateAndApplyDefaults(config: Partial<WebUiConfigType>): WebUiConfigType {
-        new Ajv({ coerceTypes: true, useDefaults: true }).compile(WebUiConfigSchema)(config);
-        return config as WebUiConfigType;
-    }
-
-    private async ensureConfigFileExists(configPath: string): Promise<void> {
-        const configExists = await fs
-            .access(configPath, constants.F_OK)
-            .then(() => true)
-            .catch(() => false);
-        if (!configExists) {
-            await fs.writeFile(configPath, JSON.stringify(this.validateAndApplyDefaults({}), null, 4));
-        }
-    }
-
-    private async readAndValidateConfig(configPath: string): Promise<WebUiConfigType> {
-        const fileContent = await fs.readFile(configPath, 'utf-8');
-        return this.validateAndApplyDefaults(JSON.parse(fileContent));
-    }
-
-    private async writeConfig(configPath: string, config: WebUiConfigType): Promise<void> {
-        const hasWritePermission = await fs
-            .access(configPath, constants.W_OK)
-            .then(() => true)
-            .catch(() => false);
-        if (hasWritePermission) {
-            await fs.writeFile(configPath, JSON.stringify(config, null, 4));
-        } else {
-            console.warn(`文件: ${configPath} 没有写入权限, 配置的更改部分可能会在重启后还原.`);
-        }
-    }
-
-    async GetWebUIConfig(): Promise<WebUiConfigType> {
-        if (this.WebUiConfigData) {
-            return this.WebUiConfigData;
-        }
-        try {
-            const configPath = resolve(webUiPathWrapper.configPath, './webui.json');
-            await this.ensureConfigFileExists(configPath);
-            const parsedConfig = await this.readAndValidateConfig(configPath);
-            this.WebUiConfigData = parsedConfig;
-            return this.WebUiConfigData;
-        } catch (e) {
-            console.log('读取配置文件失败', e);
-            return this.validateAndApplyDefaults({});
-        }
-    }
-
-    async UpdateWebUIConfig(newConfig: Partial<WebUiConfigType>): Promise<void> {
-        const configPath = resolve(webUiPathWrapper.configPath, './webui.json');
-        const currentConfig = await this.GetWebUIConfig();
-        const mergedConfig = deepMerge({ ...currentConfig }, newConfig);
-        const updatedConfig = this.validateAndApplyDefaults(mergedConfig);
-        await this.writeConfig(configPath, updatedConfig);
-        this.WebUiConfigData = updatedConfig;
-    }
-
-    async UpdateToken(oldToken: string, newToken: string): Promise<void> {
-        const currentConfig = await this.GetWebUIConfig();
-        if (currentConfig.token !== oldToken) {
-            throw new Error('旧 token 不匹配');
-        }
-        await this.UpdateWebUIConfig({ token: newToken });
-    }
-
-    // 获取日志文件夹路径
-    async GetLogsPath(): Promise<string> {
-        return resolve(webUiPathWrapper.logsPath);
-    }
-
-    // 获取日志列表
-    async GetLogsList(): Promise<string[]> {
-        const logsPath = resolve(webUiPathWrapper.logsPath);
-        const logsExist = await fs
-            .access(logsPath, constants.F_OK)
-            .then(() => true)
-            .catch(() => false);
-        if (logsExist) {
-            return (await fs.readdir(logsPath))
-                .filter((file) => file.endsWith('.log'))
-                .map((file) => file.replace('.log', ''));
-        }
-        return [];
-    }
-
-    // 获取指定日志文件内容
-    async GetLogContent(filename: string): Promise<string> {
-        const logPath = resolve(webUiPathWrapper.logsPath, `${filename}.log`);
-        const logExists = await fs
-            .access(logPath, constants.R_OK)
-            .then(() => true)
-            .catch(() => false);
-        if (logExists) {
-            return await fs.readFile(logPath, 'utf-8');
-        }
-        return '';
-    }
-
-    // 获取字体文件夹内的字体列表
-    async GetFontList(): Promise<string[]> {
-        const fontsPath = resolve(webUiPathWrapper.configPath, './fonts');
-        const fontsExist = await fs
-            .access(fontsPath, constants.F_OK)
-            .then(() => true)
-            .catch(() => false);
-        if (fontsExist) {
-            return (await fs.readdir(fontsPath)).filter((file) => file.endsWith('.ttf'));
-        }
-        return [];
-    }
-
-    // 判断字体是否存在（webui.woff）
-    async CheckWebUIFontExist(): Promise<boolean> {
-        const fontsPath = resolve(webUiPathWrapper.configPath, './fonts');
-        return await fs
-            .access(resolve(fontsPath, './webui.woff'), constants.F_OK)
-            .then(() => true)
-            .catch(() => false);
-    }
-
-    // 获取webui字体文件路径
-    GetWebUIFontPath(): string {
-        return resolve(webUiPathWrapper.configPath, './fonts/webui.woff');
-    }
-
-    getAutoLoginAccount(): string | undefined {
-        return this.WebUiConfigData?.autoLoginAccount;
-    }
-
-    // 获取自动登录账号
-    async GetAutoLoginAccount(): Promise<string> {
-        return (await this.GetWebUIConfig()).autoLoginAccount;
-    }
-
-    // 更新自动登录账号
-    async UpdateAutoLoginAccount(uin: string): Promise<void> {
-        await this.UpdateWebUIConfig({ autoLoginAccount: uin });
-    }
-
-    // 获取主题内容
-    async GetTheme(): Promise<WebUiConfigType['theme']> {
-        const config = await this.GetWebUIConfig();
-
-        return config.theme;
-    }
-
-    // 更新主题内容
-    async UpdateTheme(theme: WebUiConfigType['theme']): Promise<void> {
-        await this.UpdateWebUIConfig({ theme: theme });
-    }
-}

src/webui/src/middleware/auth.ts

@@ -1,47 +0,0 @@
-import { NextFunction, Request, Response } from 'express';
-
-import { WebUiConfig } from '@/webui';
-
-import { AuthHelper } from '@webapi/helper/SignToken';
-import { sendError } from '@webapi/utils/response';
-
-// 鉴权中间件
-export async function auth(req: Request, res: Response, next: NextFunction) {
-    // 判断当前url是否为/login 如果是跳过鉴权
-    if (req.url == '/auth/login') {
-        return next();
-    }
-
-    // 判断是否有Authorization头
-    if (req.headers?.authorization) {
-        // 切割参数以获取token
-        const authorization = req.headers.authorization.split(' ');
-        // 当Bearer后面没有参数时
-        if (authorization.length < 2) {
-            return sendError(res, 'Unauthorized');
-        }
-        // 获取token
-        const hash = authorization[1];
-        if(!hash) return sendError(res, 'Unauthorized');
-        // 解析token
-        let Credential: WebUiCredentialJson;
-        try {
-            Credential = JSON.parse(Buffer.from(hash, 'base64').toString('utf-8'));
-        } catch (e) {
-            return sendError(res, 'Unauthorized');
-        }
-        // 获取配置
-        const config = await WebUiConfig.GetWebUIConfig();
-        // 验证凭证在1小时内有效
-        const credentialJson = AuthHelper.validateCredentialWithinOneHour(config.token, Credential);
-        if (credentialJson) {
-            // 通过验证
-            return next();
-        }
-        // 验证失败
-        return sendError(res, 'Unauthorized');
-    }
-
-    // 没有Authorization头
-    return sendError(res, 'Unauthorized');
-}

src/webui/src/middleware/cors.ts

@@ -1,16 +0,0 @@
-import type { RequestHandler } from 'express';
-
-// CORS 中间件，跨域用
-export const cors: RequestHandler = (req, res, next) => {
-    const origin = req.headers.origin || '*';
-    res.header('Access-Control-Allow-Origin', origin);
-    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-    res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
-    res.header('Access-Control-Allow-Credentials', 'true');
-
-    if (req.method === 'OPTIONS') {
-        res.sendStatus(204);
-        return;
-    }
-    next();
-};

src/webui/src/router/Base.ts

@@ -1,15 +0,0 @@
-import { Router } from 'express';
-import { GetThemeConfigHandler, PackageInfoHandler, QQVersionHandler, SetThemeConfigHandler } from '../api/BaseInfo';
-import { StatusRealTimeHandler } from '@webapi/api/Status';
-import { GetProxyHandler } from '../api/Proxy';
-
-const router = Router();
-// router: 获取nc的package.json信息
-router.get('/QQVersion', QQVersionHandler);
-router.get('/PackageInfo', PackageInfoHandler);
-router.get('/GetSysStatusRealTime', StatusRealTimeHandler);
-router.get('/proxy', GetProxyHandler);
-router.get('/Theme', GetThemeConfigHandler);
-router.post('/SetTheme', SetThemeConfigHandler);
-
-export { router as BaseRouter };

src/webui/src/router/File.ts

@@ -1,49 +0,0 @@
-import { Router } from 'express';
-import rateLimit from 'express-rate-limit';
-import {
-    ListFilesHandler,
-    CreateDirHandler,
-    DeleteHandler,
-    ReadFileHandler,
-    WriteFileHandler,
-    CreateFileHandler,
-    BatchDeleteHandler, // 添加这一行
-    RenameHandler,
-    MoveHandler,
-    BatchMoveHandler,
-    DownloadHandler,
-    BatchDownloadHandler, // 新增下载处理方法
-    UploadHandler,
-    UploadWebUIFontHandler,
-    DeleteWebUIFontHandler, // 添加上传处理器
-} from '../api/File';
-
-const router = Router();
-
-const apiLimiter = rateLimit({
-    windowMs: 1 * 60 * 1000, // 1分钟内
-    max: 60, // 最大60个请求
-    validate: {
-        xForwardedForHeader: false,
-    },
-});
-
-router.use(apiLimiter);
-
-router.get('/list', ListFilesHandler);
-router.post('/mkdir', CreateDirHandler);
-router.post('/delete', DeleteHandler);
-router.get('/read', ReadFileHandler);
-router.post('/write', WriteFileHandler);
-router.post('/create', CreateFileHandler);
-router.post('/batchDelete', BatchDeleteHandler);
-router.post('/rename', RenameHandler);
-router.post('/move', MoveHandler);
-router.post('/batchMove', BatchMoveHandler);
-router.post('/download', DownloadHandler);
-router.post('/batchDownload', BatchDownloadHandler);
-router.post('/upload', UploadHandler);
-
-router.post('/font/upload/webui', UploadWebUIFontHandler);
-router.post('/font/delete/webui', DeleteWebUIFontHandler);
-export { router as FileRouter };

src/webui/src/router/Log.ts

@@ -1,23 +0,0 @@
-import { Router } from 'express';
-import {
-    LogHandler,
-    LogListHandler,
-    LogRealTimeHandler,
-    CreateTerminalHandler,
-    GetTerminalListHandler,
-    CloseTerminalHandler,
-} from '../api/Log';
-
-const router = Router();
-
-// 日志相关路由
-router.get('/GetLog', LogHandler);
-router.get('/GetLogList', LogListHandler);
-router.get('/GetLogRealTime', LogRealTimeHandler);
-
-// 终端相关路由
-router.get('/terminal/list', GetTerminalListHandler);
-router.post('/terminal/create', CreateTerminalHandler);
-router.post('/terminal/:id/close', CloseTerminalHandler);
-
-export { router as LogRouter };

src/webui/src/router/OB11Config.ts

@@ -1,11 +0,0 @@
-import { Router } from 'express';
-
-import { OB11GetConfigHandler, OB11SetConfigHandler } from '@webapi/api/OB11Config';
-
-const router = Router();
-// router:读取配置
-router.post('/GetConfig', OB11GetConfigHandler);
-// router:写入配置
-router.post('/SetConfig', OB11SetConfigHandler);
-
-export { router as OB11ConfigRouter };

src/webui/src/router/QQLogin.ts

@@ -1,32 +0,0 @@
-import { Router } from 'express';
-
-import {
-    QQCheckLoginStatusHandler,
-    QQGetQRcodeHandler,
-    QQGetQuickLoginListHandler,
-    QQSetQuickLoginHandler,
-    QQGetLoginListNewHandler,
-    getQQLoginInfoHandler,
-    getAutoLoginAccountHandler,
-    setAutoLoginAccountHandler,
-} from '@webapi/api/QQLogin';
-
-const router = Router();
-// router:获取快速登录列表
-router.all('/GetQuickLoginList', QQGetQuickLoginListHandler);
-// router:获取快速登录列表（新）
-router.all('/GetQuickLoginListNew', QQGetLoginListNewHandler);
-// router:检查QQ登录状态
-router.post('/CheckLoginStatus', QQCheckLoginStatusHandler);
-// router:获取QQ登录二维码
-router.post('/GetQQLoginQrcode', QQGetQRcodeHandler);
-// router:设置QQ快速登录
-router.post('/SetQuickLogin', QQSetQuickLoginHandler);
-// router:获取QQ登录信息
-router.post('/GetQQLoginInfo', getQQLoginInfoHandler);
-// router:获取快速登录QQ账号
-router.post('/GetQuickLoginQQ', getAutoLoginAccountHandler);
-// router:设置自动登录QQ账号
-router.post('/SetQuickLoginQQ', setAutoLoginAccountHandler);
-
-export { router as QQLoginRouter };

src/webui/src/router/auth.ts

@@ -1,23 +0,0 @@
-import { Router } from 'express';
-
-import {
-    CheckDefaultTokenHandler,
-    checkHandler,
-    LoginHandler,
-    LogoutHandler,
-    UpdateTokenHandler,
-} from '@webapi/api/Auth';
-
-const router = Router();
-// router:登录
-router.post('/login', LoginHandler);
-// router:检查登录状态
-router.post('/check', checkHandler);
-// router:注销
-router.post('/logout', LogoutHandler);
-// router:更新token
-router.post('/update_token', UpdateTokenHandler);
-// router:检查默认token
-router.get('/check_using_default_token', CheckDefaultTokenHandler);
-
-export { router as AuthRouter };

src/webui/src/router/index.ts

@@ -1,39 +0,0 @@
-/**
- * @file 所有路由的入口文件
- */
-
-import { Router } from 'express';
-
-import { OB11ConfigRouter } from '@webapi/router/OB11Config';
-import { auth } from '@webapi/middleware/auth';
-import { sendSuccess } from '@webapi/utils/response';
-
-import { QQLoginRouter } from '@webapi/router/QQLogin';
-import { AuthRouter } from '@webapi/router/auth';
-import { LogRouter } from '@webapi/router/Log';
-import { BaseRouter } from '@webapi/router/Base';
-import { FileRouter } from './File';
-
-const router = Router();
-
-// 鉴权中间件
-router.use(auth);
-
-// router:测试用
-router.all('/test', (_, res) => {
-    return sendSuccess(res);
-});
-// router:基础信息相关路由
-router.use('/base', BaseRouter);
-// router:WebUI登录相关路由
-router.use('/auth', AuthRouter);
-// router:QQ登录相关路由
-router.use('/QQLogin', QQLoginRouter);
-// router:OB11配置相关路由
-router.use('/OB11Config', OB11ConfigRouter);
-// router:日志相关路由
-router.use('/Log', LogRouter);
-// file:文件相关路由
-router.use('/File', FileRouter);
-
-export { router as ALLRouter };

src/webui/src/terminal/init-dynamic-dirname.ts

@@ -1,21 +0,0 @@
-import path from 'path';
-
-Object.defineProperty(global, '__dirname', {
-    get() {
-        const err = new Error();
-        const stack = err.stack?.split('\n') || [];
-        let callerFile = '';
-        // 遍历错误堆栈，跳过当前文件所在行
-        // 注意：堆栈格式可能不同，请根据实际环境调整索引及正则表达式
-        for (const line of stack) {
-            const match = line.match(/\((.*):\d+:\d+\)/);
-            if (match) {
-                callerFile = match[1];
-                if (!callerFile.includes('init-dynamic-dirname.ts')) {
-                    break;
-                }
-            }
-        }
-        return callerFile ? path.dirname(callerFile) : '';
-    },
-});

src/webui/src/terminal/terminal_manager.ts

@@ -1,183 +0,0 @@
-import './init-dynamic-dirname';
-import { WebUiConfig } from '@/webui';
-import { AuthHelper } from '../helper/SignToken';
-import { LogWrapper } from '@/common/log';
-import { WebSocket, WebSocketServer } from 'ws';
-import os from 'os';
-import { IPty, spawn as ptySpawn } from '@/pty';
-import { randomUUID } from 'crypto';
-
-interface TerminalInstance {
-    pty: IPty; // 改用 PTY 实例
-    lastAccess: number;
-    sockets: Set<WebSocket>;
-    // 新增标识，用于防止重复关闭
-    isClosing: boolean;
-    // 新增：存储终端历史输出
-    buffer: string;
-}
-
-class TerminalManager {
-    private terminals: Map<string, TerminalInstance> = new Map();
-    private wss: WebSocketServer | null = null;
-
-    initialize(req: any, socket: any, head: any, logger?: LogWrapper) {
-        logger?.log('[NapCat] [WebUi] terminal websocket initialized');
-        this.wss = new WebSocketServer({
-            noServer: true,
-            verifyClient: async (info, cb) => {
-                // 验证 token
-                const url = new URL(info.req.url || '', 'ws://localhost');
-                const token = url.searchParams.get('token');
-                const terminalId = url.searchParams.get('id');
-
-                if (!token || !terminalId) {
-                    cb(false, 401, 'Unauthorized');
-                    return;
-                }
-
-                // 解析token
-                let Credential: WebUiCredentialJson;
-                try {
-                    Credential = JSON.parse(Buffer.from(token, 'base64').toString('utf-8'));
-                } catch (e) {
-                    cb(false, 401, 'Unauthorized');
-                    return;
-                }
-                const config = await WebUiConfig.GetWebUIConfig();
-                const validate = AuthHelper.validateCredentialWithinOneHour(config.token, Credential);
-                if (!validate) {
-                    cb(false, 401, 'Unauthorized');
-                    return;
-                }
-                cb(true);
-            },
-        });
-        this.wss.handleUpgrade(req, socket, head, (ws) => {
-            this.wss?.emit('connection', ws, req);
-        });
-        this.wss.on('connection', async (ws, req) => {
-            logger?.log('建立终端连接');
-            try {
-                const url = new URL(req.url || '', 'ws://localhost');
-                const terminalId = url.searchParams.get('id')!;
-
-                const instance = this.terminals.get(terminalId);
-
-                if (!instance) {
-                    ws.close();
-                    return;
-                }
-
-                instance.sockets.add(ws);
-                instance.lastAccess = Date.now();
-
-                // 新增：发送当前终端内容给新连接
-                if (ws.readyState === WebSocket.OPEN) {
-                    ws.send(JSON.stringify({ type: 'output', data: instance.buffer }));
-                }
-
-                ws.on('message', (data) => {
-                    if (instance) {
-                        const result = JSON.parse(data.toString());
-                        if (result.type === 'input') {
-                            instance.pty.write(result.data);
-                        }
-                        // 新增：处理 resize 消息
-                        if (result.type === 'resize') {
-                            instance.pty.resize(result.cols, result.rows);
-                        }
-                    }
-                });
-
-                ws.on('close', () => {
-                    instance.sockets.delete(ws);
-                    if (instance.sockets.size === 0 && !instance.isClosing) {
-                        instance.isClosing = true;
-                        if (os.platform() === 'win32') {
-                            process.kill(instance.pty.pid);
-                        } else {
-                            instance.pty.kill();
-                        }
-                    }
-                });
-            } catch (err) {
-                console.error('WebSocket authentication failed:', err);
-                ws.close();
-            }
-        });
-    }
-
-    // 修改：新增 cols 和 rows 参数，同步 xterm 尺寸，防止错位
-    createTerminal(cols: number, rows: number) {
-        const id = randomUUID();
-        const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
-        const pty = ptySpawn(shell, [], {
-            name: 'xterm-256color',
-            cols, // 使用客户端传入的 cols
-            rows, // 使用客户端传入的 rows
-            cwd: process.cwd(),
-            env: {
-                ...process.env,
-                LANG: os.platform() === 'win32' ? 'chcp 65001' : 'zh_CN.UTF-8',
-                TERM: 'xterm-256color',
-            },
-        });
-
-        const instance: TerminalInstance = {
-            pty,
-            lastAccess: Date.now(),
-            sockets: new Set(),
-            isClosing: false,
-            buffer: '', // 初始化终端内容缓存
-        };
-
-        pty.onData((data: any) => {
-            // 追加数据到 buffer
-            instance.buffer += data;
-            // 发送数据给已连接的 websocket
-            instance.sockets.forEach((ws) => {
-                if (ws.readyState === WebSocket.OPEN) {
-                    ws.send(JSON.stringify({ type: 'output', data }));
-                }
-            });
-        });
-
-        pty.onExit(() => {
-            this.closeTerminal(id);
-        });
-
-        this.terminals.set(id, instance);
-        // 返回生成的 id 及对应实例，方便后续通知客户端使用该 id
-        return { id, instance };
-    }
-
-    closeTerminal(id: string) {
-        const instance = this.terminals.get(id);
-        if (instance) {
-            if (!instance.isClosing) {
-                instance.isClosing = true;
-                if (os.platform() === 'win32') {
-                    process.kill(instance.pty.pid);
-                } else {
-                    instance.pty.kill();
-                }
-            }
-            instance.sockets.forEach((ws) => ws.close());
-            this.terminals.delete(id);
-        }
-    }
-
-    getTerminal(id: string) {
-        return this.terminals.get(id);
-    }
-
-    getTerminalList() {
-        return Array.from(this.terminals.keys()).map((id) => ({
-            id,
-            lastAccess: this.terminals.get(id)!.lastAccess,
-        }));
-    }
-}
-
-export const terminalManager = new TerminalManager();

src/webui/src/types/config.d.ts

@@ -1,6 +0,0 @@
-interface WebUiConfigType {
-    host: string;
-    port: number;
-    token: string;
-    loginRate: number;
-}

src/webui/src/types/data.d.ts

@@ -1,20 +0,0 @@
-import type { LoginListItem, SelfInfo } from '@/core';
-import type { OneBotConfig } from '@/onebot/config/config';
-
-interface LoginRuntimeType {
-    LoginCurrentTime: number;
-    LoginCurrentRate: number;
-    QQLoginStatus: boolean;
-    QQQRCodeURL: string;
-    QQLoginUin: string;
-    QQLoginInfo: SelfInfo;
-    QQVersion: string;
-    WebUiConfigQuickFunction: () => Promise<void>;
-    NapCatHelper: {
-        onQuickLoginRequested: (uin: string) => Promise<{ result: boolean; message: string }>;
-        onOB11ConfigChanged: (ob11: OneBotConfig) => Promise<void>;
-        QQLoginList: string[];
-        NewQQLoginList: LoginListItem[];
-    };
-    packageJson: object;
-}

src/webui/src/types/server.d.ts

@@ -1,7 +0,0 @@
-interface APIResponse<T> {
-    code: number;
-    message: string;
-    data: T;
-}
-
-type Protocol = 'http' | 'https' | 'ws' | 'wss';