Merge branch 'main' of https://github.com/NapNeko/NapCatQQ

Rebuilt and replaced the napi2native.node binaries for Darwin ARM64, Linux ARM64, Linux x64, and Windows x64. This likely includes bug fixes, performance improvements, or compatibility updates in the native module.

.vscode/settings.json

@@ -9,4 +9,9 @@
     "css.customData": [
         ".vscode/tailwindcss.json"
     ],
-}
+    "editor.formatOnPaste": false,
+     "editor.formatOnSave": false,
+    "editor.codeActionsOnSave": {
+        "source.fixAll.eslint": "never"
+    },
+}

README.md

@@ -13,6 +13,15 @@ _Modern protocol-side framework implemented based on NTQQ._
 
 ---
 
+## New Feature
+在 v4.8.115+ 版本开始
+
+1. NapCatQQ 支持 [Stream Api](https://napneko.github.io/develop/file)
+2. NapCatQQ 推荐 message_id/user_id/group_id 均使用字符串类型
+
+- [1] 解决 Docker/跨设备/大文件 的多媒体上下传问题
+- [2] 采用字符串可以解决扩展到int64的问题，同时也可以解决部分语言（如JavaScript）对大整数支持不佳的问题，增加极少成本。
+
 ## Welcome
 + NapCatQQ is a modern implementation of the Bot protocol based on NTQQ.
   - NapCatQQ 是现代化的基于 NTQQ 的 Bot 协议端实现
@@ -33,6 +42,7 @@ _Modern protocol-side framework implemented based on NTQQ._
 
 **首次使用**请务必查看如下文档看使用教程
 
+> 项目非盈利，对接问题/基础问题/下层框架问题 请自行搜索解决，本项目社区不提供此类解答。
 ## Link
 
 | 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/) |
@@ -41,12 +51,17 @@ _Modern protocol-side framework implemented based on NTQQ._
 | 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) |
 |:-:|:-:|:-:|:-:|
 
-| QQ Group | [![QQ Group#4](https://img.shields.io/badge/QQ%20Group%234-Join-blue)](https://qm.qq.com/q/CMmPbGw0jA) | [![QQ Group#3](https://img.shields.io/badge/QQ%20Group%233-Join-blue)](https://qm.qq.com/q/8zJMLjqy2Y) | [![QQ Group#2](https://img.shields.io/badge/QQ%20Group%232-Join-blue)](https://qm.qq.com/q/HaRcfrHpUk) | [![QQ Group#1](https://img.shields.io/badge/QQ%20Group%231-Join-blue)](https://qm.qq.com/q/I6LU87a0Yq) |
+| QQ Group | [![QQ Group#4](https://img.shields.io/badge/QQ%20Group%234-Join-blue)](https://qm.qq.com/q/CMmPbGw0jA) | [![QQ Group#3](https://img.shields.io/badge/QQ%20Group%233-Join-blue)](https://qm.qq.com/q/8zJMLjqy2Y) | [![QQ Group#2](https://img.shields.io/badge/QQ%20Group%232-Join-blue)](https://qm.qq.com/q/CMmPbGw0jA) | [![QQ Group#1](https://img.shields.io/badge/QQ%20Group%231-Join-blue)](https://qm.qq.com/q/I6LU87a0Yq) |
 |:-:|:-:|:-:|:-:|:-:|
 
 | Telegram | [![Telegram](https://img.shields.io/badge/Telegram-napcatqq-blue)](https://t.me/napcatqq) |
 |:-:|:-:|
 
+| DeepWiki | [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/NapNeko/NapCatQQ) |
+|:-:|:-:|
+
+> 请不要在其余社区提及本项目(包括其余协议端/相关应用端项目)引发争论，如有建议到达官方交流群讨论或PR。
+
 ## Thanks
 
 + [Lagrange](https://github.com/LagrangeDev/Lagrange.Core) 对本项目的大力支持 参考部分代码 已获授权

launcher/launcher-user.bat

@@ -7,7 +7,7 @@ set NAPCAT_LAUNCHER_PATH=%cd%\NapCatWinBootMain.exe
 set NAPCAT_MAIN_PATH=%cd%\napcat.mjs
 :loop_read
 for /f "tokens=2*" %%a in ('reg query "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\QQ" /v "UninstallString"') do (
-    set RetString=%%b
+     set "RetString=%%~b"
     goto :napcat_boot
 )
 
@@ -16,7 +16,7 @@ for %%a in ("%RetString%") do (
     set "pathWithoutUninstall=%%~dpa"
 )
 
-SET QQPath=%pathWithoutUninstall%QQ.exe
+set "QQPath=%pathWithoutUninstall%QQ.exe"
 
 if not exist "%QQpath%" (
     echo provided QQ path is invalid

launcher/launcher-win10-user.bat

@@ -7,7 +7,7 @@ set NAPCAT_LAUNCHER_PATH=%cd%\NapCatWinBootMain.exe
 set NAPCAT_MAIN_PATH=%cd%\napcat.mjs
 :loop_read
 for /f "tokens=2*" %%a in ('reg query "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\QQ" /v "UninstallString"') do (
-    set RetString=%%b
+    set "RetString=%%~b"
     goto :napcat_boot
 )
 
@@ -16,7 +16,7 @@ for %%a in ("%RetString%") do (
     set "pathWithoutUninstall=%%~dpa"
 )
 
-SET QQPath=%pathWithoutUninstall%QQ.exe
+set "QQPath=%pathWithoutUninstall%QQ.exe"
 
 if not exist "%QQpath%" (
     echo provided QQ path is invalid

launcher/launcher-win10.bat

@@ -16,7 +16,7 @@ set NAPCAT_LAUNCHER_PATH=%cd%\NapCatWinBootMain.exe
 set NAPCAT_MAIN_PATH=%cd%\napcat.mjs
 :loop_read
 for /f "tokens=2*" %%a in ('reg query "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\QQ" /v "UninstallString"') do (
-    set RetString=%%b
+    set "RetString=%%~b"
     goto :napcat_boot
 )
 
@@ -25,7 +25,7 @@ for %%a in ("%RetString%") do (
     set "pathWithoutUninstall=%%~dpa"
 )
 
-SET QQPath=%pathWithoutUninstall%QQ.exe
+set "QQPath=%pathWithoutUninstall%QQ.exe"
 
 if not exist "%QQPath%" (
     echo provided QQ path is invalid

launcher/launcher.bat

@@ -16,7 +16,7 @@ set NAPCAT_LAUNCHER_PATH=%cd%\NapCatWinBootMain.exe
 set NAPCAT_MAIN_PATH=%cd%\napcat.mjs
 :loop_read
 for /f "tokens=2*" %%a in ('reg query "HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\QQ" /v "UninstallString"') do (
-    set RetString=%%b
+    set "RetString=%%~b"
     goto :napcat_boot
 )
 
@@ -25,7 +25,7 @@ for %%a in ("%RetString%") do (
     set "pathWithoutUninstall=%%~dpa"
 )
 
-SET QQPath=%pathWithoutUninstall%QQ.exe
+set "QQPath=%pathWithoutUninstall%QQ.exe"
 
 if not exist "%QQPath%" (
     echo provided QQ path is invalid

launcher/qqnt.json

@@ -1,9 +1,9 @@
 {
   "name": "qq-chat",
-  "verHash": "cc326038",
-  "version": "9.9.21-39038",
-  "linuxVersion": "3.2.19-39038",
-  "linuxVerHash": "c773cdf7",
+  "verHash": "c50d6326",
+  "version": "9.9.22-40768",
+  "linuxVersion": "3.2.20-40768",
+  "linuxVerHash": "ab90fdfa",
   "private": true,
   "description": "QQ",
   "productName": "QQ",
@@ -17,7 +17,7 @@
     "qd": "externals/devtools/cli/index.js"
   },
   "main": "./loadNapCat.js",
-  "buildVersion": "39038",
+  "buildVersion": "40768",
   "isPureShell": true,
   "isByteCodeShell": true,
   "platform": "win32",

manifest.json

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

napcat.webui/src/components/display_card/common_card.tsx

@@ -62,24 +62,39 @@ const NetworkDisplayCard = <T extends keyof NetworkType>({
         <ButtonGroup
           fullWidth
           isDisabled={editing}
-          radius="full"
+          radius="sm"
           size="sm"
-          variant="shadow"
+          variant="flat"
         >
-          <Button color="warning" startContent={<FiEdit3 />} onPress={onEdit}>
+          <Button
+            color="warning"
+            startContent={<FiEdit3 size={16} />}
+            onPress={onEdit}
+          >
             编辑
           </Button>
 
           <Button
-            color={debug ? 'success' : 'default'}
-            startContent={<CgDebug />}
+            color={debug ? 'secondary' : 'success'}
+            variant="flat"
+            startContent={
+              <CgDebug
+                style={{
+                  width: '16px',
+                  height: '16px',
+                  minWidth: '16px',
+                  minHeight: '16px'
+                }}
+              />
+            }
             onPress={handleEnableDebug}
           >
             {debug ? '关闭调试' : '开启调试'}
           </Button>
           <Button
-            color="primary"
-            startContent={<MdDeleteForever />}
+            className="bg-danger/20 text-danger hover:bg-danger/30 transition-colors"
+            variant="flat"
+            startContent={<MdDeleteForever size={16} />}
             onPress={handleDelete}
           >
             删除

napcat.webui/src/components/file_manage/file_table.tsx

@@ -82,6 +82,7 @@ export default function FileTable({
     setPreviewImages([])
     setPreviewIndex(0)
     setShowImage(false)
+    setPage(1)
   }, [currentPath])
 
   const onPreviewImage = (name: string, images: PreviewImage[]) => {

napcat.webui/src/components/network_edit/generic_form.tsx

@@ -171,7 +171,8 @@ const GenericForm = <T extends keyof NetworkConfigType>({
 
 export default GenericForm
 export function random_token(length: number) {
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@#$%^&*()-_=+[]{}|;:,.<>?'
+  const chars =
+    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@#$%^&*()-_=+[]{}|;:,.<>?'
   let result = ''
   for (let i = 0; i < length; i++) {
     result += chars.charAt(Math.floor(Math.random() * chars.length))

napcat.webui/src/controllers/webui_manager.ts

@@ -1,9 +1,10 @@
+import CryptoJS from 'crypto-js'
 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,7 +18,7 @@ export default class WebUIManager {
   }
 
   public static async loginWithToken(token: string) {
-    const sha256 = CryptoJS.SHA256(token + '.napcat').toString();
+    const sha256 = CryptoJS.SHA256(token + '.napcat').toString()
     const { data } = await serverRequest.post<ServerResponse<AuthResponse>>(
       '/auth/login',
       { hash: sha256 }
@@ -33,21 +34,6 @@ export default class WebUIManager {
     return data.data
   }
 
-  public static async changePasswordFromDefault(newToken: string) {
-    const { data } = await serverRequest.post<ServerResponse<boolean>>(
-      '/auth/update_token',
-      { newToken, fromDefault: true }
-    )
-    return data.data
-  }
-
-  public static async checkUsingDefaultToken() {
-    const { data } = await serverRequest.get<ServerResponse<boolean>>(
-      '/auth/check_using_default_token'
-    )
-    return data.data
-  }
-
   public static async proxy<T>(url = '') {
     const data = await serverRequest.get<ServerResponse<string>>(
       '/base/proxy?url=' + encodeURIComponent(url)

napcat.webui/src/pages/dashboard/config/change_password.tsx

@@ -1,6 +1,5 @@
 import { Input } from '@heroui/input'
 import { useLocalStorage } from '@uidotdev/usehooks'
-import { useEffect, useState } from 'react'
 import { Controller, useForm } from 'react-hook-form'
 import toast from 'react-hot-toast'
 import { useNavigate } from 'react-router-dom'
@@ -12,14 +11,12 @@ import SaveButtons from '@/components/button/save_buttons'
 import WebUIManager from '@/controllers/webui_manager'
 
 const ChangePasswordCard = () => {
-  const [isDefaultToken, setIsDefaultToken] = useState<boolean>(false)
-  const [isLoadingCheck, setIsLoadingCheck] = useState<boolean>(true)
-
   const {
     control,
     handleSubmit: handleWebuiSubmit,
-    formState: { isSubmitting },
-    reset
+    formState: { isSubmitting, errors },
+    reset,
+    watch
   } = useForm<{
     oldToken: string
     newToken: string
@@ -33,31 +30,13 @@ const ChangePasswordCard = () => {
   const navigate = useNavigate()
   const [_, setToken] = useLocalStorage(key.token, '')
 
-  // 检查是否使用默认密码
-  useEffect(() => {
-    const checkDefaultToken = async () => {
-      try {
-        const isDefault = await WebUIManager.checkUsingDefaultToken()
-        setIsDefaultToken(isDefault)
-      } catch (error) {
-        console.error('检查默认密码状态失败:', error)
-      } finally {
-        setIsLoadingCheck(false)
-      }
-    }
-
-    checkDefaultToken()
-  }, [])
+  // 监听旧密码的值
+  const oldTokenValue = watch('oldToken')
 
   const onSubmit = handleWebuiSubmit(async (data) => {
     try {
-      if (isDefaultToken) {
-        // 从默认密码更新
-        await WebUIManager.changePasswordFromDefault(data.newToken)
-      } else {
-        // 正常密码更新
-        await WebUIManager.changePassword(data.oldToken, data.newToken)
-      }
+      // 使用正常密码更新流程
+      await WebUIManager.changePassword(data.oldToken, data.newToken)
 
       toast.success('修改成功')
       setToken('')
@@ -69,53 +48,74 @@ const ChangePasswordCard = () => {
     }
   })
 
-  if (isLoadingCheck) {
-    return (
-      <>
-        <title>修改密码 - NapCat WebUI</title>
-        <div className="flex justify-center items-center h-32">
-          <div className="text-center">加载中...</div>
-        </div>
-      </>
-    )
-  }
-
   return (
     <>
       <title>修改密码 - NapCat WebUI</title>
 
-      {isDefaultToken && (
-        <div className="mb-4 p-3 bg-warning-50 border border-warning-200 rounded-lg">
-          <p className="text-warning-700 text-sm">
-            检测到您正在使用默认密码，为了安全起见，请立即设置新密码。
-          </p>
-        </div>
-      )}
-
-      {!isDefaultToken && (
-        <Controller
-          control={control}
-          name="oldToken"
-          render={({ field }) => (
-            <Input
-              {...field}
-              label="旧密码"
-              placeholder="请输入旧密码"
-              type="password"
-            />
-          )}
-        />
-      )}
+      <Controller
+        control={control}
+        name="oldToken"
+        rules={{
+          required: '旧密码不能为空',
+          validate: (value) => {
+            if (!value || value.trim().length === 0) {
+              return '旧密码不能为空'
+            }
+            return true
+          }
+        }}
+        render={({ field }) => (
+          <Input
+            {...field}
+            label="旧密码"
+            placeholder="请输入旧密码"
+            type="password"
+            isRequired
+            isInvalid={!!errors.oldToken}
+            errorMessage={errors.oldToken?.message}
+          />
+        )}
+      />
 
       <Controller
         control={control}
         name="newToken"
+        rules={{
+          required: '新密码不能为空',
+          minLength: {
+            value: 6,
+            message: '新密码至少需要6个字符'
+          },
+          validate: (value) => {
+            if (!value || value.trim().length === 0) {
+              return '新密码不能为空'
+            }
+            if (value.trim().length !== value.length) {
+              return '新密码不能包含前后空格'
+            }
+            if (value === oldTokenValue) {
+              return '新密码不能与旧密码相同'
+            }
+            // 检查是否包含字母
+            if (!/[a-zA-Z]/.test(value)) {
+              return '新密码必须包含字母'
+            }
+            // 检查是否包含数字
+            if (!/[0-9]/.test(value)) {
+              return '新密码必须包含数字'
+            }
+            return true
+          }
+        }}
         render={({ field }) => (
           <Input
             {...field}
-            label={isDefaultToken ? "设置新密码" : "新密码"}
-            placeholder={isDefaultToken ? "请设置一个安全的新密码" : "请输入新密码"}
+            label="新密码"
+            placeholder="至少6位，包含字母和数字"
             type="password"
+            isRequired
+            isInvalid={!!errors.newToken}
+            errorMessage={errors.newToken?.message}
           />
         )}
       />

napcat.webui/src/pages/dashboard/config/server.tsx

@@ -182,4 +182,4 @@ const ServerConfigCard = () => {
   )
 }
 
-export default ServerConfigCard
+export default ServerConfigCard

napcat.webui/src/pages/index.tsx

@@ -1,52 +1,15 @@
 import { Spinner } from '@heroui/spinner'
 import { AnimatePresence, motion } from 'motion/react'
-import { Suspense, useEffect } from 'react'
-import { Outlet, useLocation, useNavigate } from 'react-router-dom'
+import { Suspense } from 'react'
+import { Outlet, useLocation } from 'react-router-dom'
 
-import useAuth from '@/hooks/auth'
-import useDialog from '@/hooks/use-dialog'
-
-import WebUIManager from '@/controllers/webui_manager'
 import DefaultLayout from '@/layouts/default'
 
-const CheckDefaultPassword = () => {
-  const { isAuth } = useAuth()
-  const dialog = useDialog()
-  const navigate = useNavigate()
-  const checkDefaultPassword = async () => {
-    const data = await WebUIManager.checkUsingDefaultToken()
-    if (data) {
-      dialog.confirm({
-        title: '修改默认密码',
-        content: '检测到当前密码为默认密码，为了您的安全，必须立即修改密码。',
-        confirmText: '前往修改',
-        onConfirm: () => {
-          navigate('/config?tab=token')
-        },
-        onCancel: () => {
-          navigate('/config?tab=token')
-        },
-        onClose() {
-          navigate('/config?tab=token')
-        },
-      })
-    }
-  }
-
-  useEffect(() => {
-    if (isAuth) {
-      checkDefaultPassword()
-    }
-  }, [isAuth])
-  return null
-}
-
 export default function IndexPage() {
   const location = useLocation()
 
   return (
     <DefaultLayout>
-      <CheckDefaultPassword />
       <Suspense
         fallback={
           <div className="flex justify-center px-10">

napcat.webui/src/pages/web_login.tsx

@@ -92,42 +92,65 @@ export default function WebLoginPage() {
             </CardHeader>
 
             <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: [
-                    'bg-transparent',
-                    'text-black/90 dark:text-white/90',
-                    'placeholder:text-default-700/50 dark:placeholder:text-white/60'
-                  ],
-                  innerWrapper: 'bg-transparent',
-                  inputWrapper: [
-                    'shadow-xl',
-                    'bg-default-100/70',
-                    'dark:bg-default/60',
-                    'backdrop-blur-xl',
-                    'backdrop-saturate-200',
-                    'hover:bg-default-0/70',
-                    'dark:hover:bg-default/70',
-                    'group-data-[focus=true]:bg-default-100/50',
-                    'dark:group-data-[focus=true]:bg-default/60',
-                    '!cursor-text'
-                  ]
+              <form
+                onSubmit={(e) => {
+                  e.preventDefault()
+                  onSubmit()
                 }}
-                isDisabled={isLoading}
-                label="Token"
-                placeholder="请输入token"
-                radius="lg"
-                size="lg"
-                startContent={
-                  <IoKeyOutline className="text-black/50 mb-0.5 dark:text-white/90 text-slate-400 pointer-events-none flex-shrink-0" />
-                }
-                value={tokenValue}
-                onChange={(e) => setTokenValue(e.target.value)}
-                onClear={() => setTokenValue('')}
-              />
+              >
+                {/* 隐藏的用户名字段，帮助浏览器识别登录表单 */}
+                <input
+                  type="text"
+                  name="username"
+                  value="napcat-webui"
+                  autoComplete="username"
+                  className="absolute -left-[9999px] opacity-0 pointer-events-none"
+                  readOnly
+                  tabIndex={-1}
+                  aria-label="Username"
+                />
+                <Input
+                  isClearable
+                  type="password"
+                  name="password"
+                  autoComplete="current-password"
+                  classNames={{
+                    label: 'text-black/50 dark:text-white/90',
+                    input: [
+                      'bg-transparent',
+                      'text-black/90 dark:text-white/90',
+                      'placeholder:text-default-700/50 dark:placeholder:text-white/60'
+                    ],
+                    innerWrapper: 'bg-transparent',
+                    inputWrapper: [
+                      'shadow-xl',
+                      'bg-default-100/70',
+                      'dark:bg-default/60',
+                      'backdrop-blur-xl',
+                      'backdrop-saturate-200',
+                      'hover:bg-default-0/70',
+                      'dark:hover:bg-default/70',
+                      'group-data-[focus=true]:bg-default-100/50',
+                      'dark:group-data-[focus=true]:bg-default/60',
+                      '!cursor-text'
+                    ]
+                  }}
+                  isDisabled={isLoading}
+                  label="Token"
+                  placeholder="请输入token"
+                  radius="lg"
+                  size="lg"
+                  startContent={
+                    <IoKeyOutline className="text-black/50 mb-0.5 dark:text-white/90 text-slate-400 pointer-events-none flex-shrink-0" />
+                  }
+                  value={tokenValue}
+                  onChange={(e) => setTokenValue(e.target.value)}
+                  onClear={() => setTokenValue('')}
+                />
+              </form>
+              <div className="text-center text-small text-default-600 dark:text-default-400 px-2">
+                💡 提示：请从 NapCat 启动日志中查看登录密钥
+              </div>
               <Button
                 className="mx-10 mt-10 text-lg py-7"
                 color="primary"

package.json

@@ -2,7 +2,7 @@
   "name": "napcat",
   "private": true,
   "type": "module",
-  "version": "4.8.109",
+  "version": "4.9.4",
   "scripts": {
     "build:universal": "npm run build:webui && vite build --mode universal || exit 1",
     "build:framework": "npm run build:webui && vite build --mode framework || exit 1",

src/common/ffmpeg-adapter-factory.ts

@@ -0,0 +1,131 @@
+/**
+ * FFmpeg Adapter Factory
+ * 自动检测并选择最佳的 FFmpeg 适配器
+ */
+
+import { LogWrapper } from './log';
+import { FFmpegAddonAdapter } from './ffmpeg-addon-adapter';
+import { FFmpegExecAdapter } from './ffmpeg-exec-adapter';
+import type { IFFmpegAdapter } from './ffmpeg-adapter-interface';
+
+/**
+ * FFmpeg 适配器工厂
+ */
+export class FFmpegAdapterFactory {
+    private static instance: IFFmpegAdapter | null = null;
+    private static initPromise: Promise<IFFmpegAdapter> | null = null;
+
+    /**
+     * 初始化并获取最佳的 FFmpeg 适配器
+     * @param logger 日志记录器
+     * @param ffmpegPath FFmpeg 可执行文件路径(用于 Exec 适配器)
+     * @param ffprobePath FFprobe 可执行文件路径(用于 Exec 适配器)
+     * @param binaryPath 二进制文件路径(来自 pathWrapper.binaryPath,用于 Addon 适配器)
+     */
+    static async getAdapter(
+        logger: LogWrapper,
+        ffmpegPath: string = 'ffmpeg',
+        ffprobePath: string = 'ffprobe',
+        binaryPath?: string
+    ): Promise<IFFmpegAdapter> {
+        // 如果已经初始化,直接返回
+        if (this.instance) {
+            return this.instance;
+        }
+
+        // 如果正在初始化,等待初始化完成
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+
+        // 开始初始化
+        this.initPromise = this.initialize(logger, ffmpegPath, ffprobePath, binaryPath);
+
+        try {
+            this.instance = await this.initPromise;
+            return this.instance;
+        } finally {
+            this.initPromise = null;
+        }
+    }
+
+    /**
+     * 初始化适配器
+     */
+    private static async initialize(
+        logger: LogWrapper,
+        ffmpegPath: string,
+        ffprobePath: string,
+        binaryPath?: string
+    ): Promise<IFFmpegAdapter> {
+
+        // 1. 优先尝试使用 Native Addon
+        if (binaryPath) {
+            const addonAdapter = new FFmpegAddonAdapter(binaryPath);
+
+            logger.log('[FFmpeg] 检查 Native Addon 可用性...');
+            if (await addonAdapter.isAvailable()) {
+                logger.log('[FFmpeg] ✓ 使用 Native Addon 适配器');
+                return addonAdapter;
+            }
+
+            logger.log('[FFmpeg] Native Addon 不可用，尝试使用命令行工具');
+        } else {
+            logger.log('[FFmpeg] 未提供 binaryPath，跳过 Native Addon 检测');
+        }
+
+        // 2. 降级到 execFile 实现
+        const execAdapter = new FFmpegExecAdapter(ffmpegPath, ffprobePath, binaryPath, logger);
+
+        logger.log(`[FFmpeg] 检查命令行工具可用性: ${ffmpegPath}`);
+        if (await execAdapter.isAvailable()) {
+            logger.log('[FFmpeg] 使用命令行工具适配器 ✓');
+            return execAdapter;
+        }
+
+        // 3. 都不可用，返回 execAdapter 但会在使用时报错
+        logger.logError('[FFmpeg] 警告: FFmpeg 不可用，将使用命令行适配器但可能失败');
+        return execAdapter;
+    }
+
+    /**
+     * 重置适配器(用于测试或重新初始化)
+     */
+    static reset(): void {
+        this.instance = null;
+        this.initPromise = null;
+    }
+
+    /**
+     * 更新 FFmpeg 路径并重新初始化
+     * @param logger 日志记录器
+     * @param ffmpegPath FFmpeg 可执行文件路径
+     * @param ffprobePath FFprobe 可执行文件路径
+     */
+    static async updateFFmpegPath(
+        logger: LogWrapper,
+        ffmpegPath: string,
+        ffprobePath: string
+    ): Promise<void> {
+        // 如果当前使用的是 Exec 适配器,更新路径
+        if (this.instance && this.instance instanceof FFmpegExecAdapter) {
+            logger.log(`[FFmpeg] 更新 FFmpeg 路径: ${ffmpegPath}`);
+            this.instance.setFFmpegPath(ffmpegPath);
+            this.instance.setFFprobePath(ffprobePath);
+
+            // 验证新路径是否可用
+            if (await this.instance.isAvailable()) {
+                logger.log('[FFmpeg] 新路径验证成功 ✓');
+            } else {
+                logger.logError('[FFmpeg] 警告: 新 FFmpeg 路径不可用');
+            }
+        }
+    }
+
+    /**
+     * 获取当前适配器(不初始化)
+     */
+    static getCurrentAdapter(): IFFmpegAdapter | null {
+        return this.instance;
+    }
+}

src/common/ffmpeg-adapter-interface.ts

@@ -0,0 +1,68 @@
+/**
+ * FFmpeg Adapter Interface
+ * 定义统一的 FFmpeg 操作接口,支持多种实现方式
+ */
+
+/**
+ * 视频信息结果
+ */
+export interface VideoInfoResult {
+    /** 视频宽度(像素) */
+    width: number;
+    /** 视频高度(像素) */
+    height: number;
+    /** 视频时长(秒) */
+    duration: number;
+    /** 容器格式 */
+    format: string;
+    /** 缩略图 Buffer */
+    thumbnail?: Buffer;
+}
+
+/**
+ * FFmpeg 适配器接口
+ */
+export interface IFFmpegAdapter {
+    /** 适配器名称 */
+    readonly name: string;
+
+    /** 是否可用 */
+    isAvailable(): Promise<boolean>;
+
+    /**
+     * 获取视频信息(包含缩略图)
+     * @param videoPath 视频文件路径
+     * @returns 视频信息
+     */
+    getVideoInfo(videoPath: string): Promise<VideoInfoResult>;
+
+    /**
+     * 获取音视频文件时长
+     * @param filePath 文件路径
+     * @returns 时长(秒)
+     */
+    getDuration(filePath: string): Promise<number>;
+
+    /**
+     * 转换音频为 PCM 格式
+     * @param filePath 输入文件路径
+     * @param pcmPath 输出 PCM 文件路径
+     * @returns PCM 数据 Buffer
+     */
+    convertToPCM(filePath: string, pcmPath: string): Promise<Buffer>;
+
+    /**
+     * 转换音频文件
+     * @param inputFile 输入文件路径
+     * @param outputFile 输出文件路径
+     * @param format 目标格式 ('amr' | 'silk' 等)
+     */
+    convertFile(inputFile: string, outputFile: string, format: string): Promise<void>;
+
+    /**
+     * 提取视频缩略图
+     * @param videoPath 视频文件路径
+     * @param thumbnailPath 缩略图输出路径
+     */
+    extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void>;
+}

src/common/ffmpeg-addon-adapter.ts

@@ -0,0 +1,129 @@
+/**
+ * FFmpeg Native Addon Adapter
+ * 使用原生 Node.js Addon 实现的 FFmpeg 适配器
+ */
+
+import { platform, arch } from 'node:os';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import type { FFmpeg } from './ffmpeg-addon';
+import type { IFFmpegAdapter, VideoInfoResult } from './ffmpeg-adapter-interface';
+import { dlopen } from 'node:process';
+
+/**
+ * 获取 Native Addon 路径
+ * @param binaryPath 二进制文件路径(来自 pathWrapper.binaryPath)
+ */
+function getAddonPath(binaryPath: string): string {
+    const platformName = platform();
+    const archName = arch();
+
+    let addonFileName: string = process.platform + '.' + process.arch;
+    let addonPath = path.join(binaryPath, "./native/ffmpeg/", `${addonFileName}.node`);
+    if (existsSync(addonPath)) {
+        throw new Error(`Unsupported platform: ${platformName} ${archName}`);
+    }
+    return addonPath;
+}
+
+/**
+ * FFmpeg Native Addon 适配器实现
+ */
+export class FFmpegAddonAdapter implements IFFmpegAdapter {
+    public readonly name = 'FFmpegAddon';
+    private addon: FFmpeg | null = null;
+    private binaryPath: string;
+
+    constructor(binaryPath: string) {
+        this.binaryPath = binaryPath;
+    }
+
+    /**
+     * 检查 Addon 是否可用
+     */
+    async isAvailable(): Promise<boolean> {
+        try {
+            const addonPath = getAddonPath(this.binaryPath);
+            if (!existsSync(addonPath)) {
+                return false;
+            }
+            let temp_addon = { exports: {} };
+            dlopen(temp_addon, addonPath);
+            this.addon = temp_addon.exports as FFmpeg;
+            return this.addon !== null;
+        } catch (error) {
+            console.log('[FFmpegAddonAdapter] Failed to load addon:', error);
+            return false;
+        }
+    }
+
+    private ensureAddon(): FFmpeg {
+        if (!this.addon) {
+            throw new Error('FFmpeg Addon is not available');
+        }
+        return this.addon;
+    }
+
+    /**
+     * 获取视频信息
+     */
+    async getVideoInfo(videoPath: string): Promise<VideoInfoResult> {
+        const addon = this.ensureAddon();
+        const info = await addon.getVideoInfo(videoPath, 'bmp24');
+
+        return {
+            width: info.width,
+            height: info.height,
+            duration: info.duration,
+            format: info.format,
+            thumbnail: info.image,
+        };
+    }
+
+    /**
+     * 获取时长
+     */
+    async getDuration(filePath: string): Promise<number> {
+        const addon = this.ensureAddon();
+        return addon.getDuration(filePath);
+    }
+
+    /**
+     * 转换为 PCM
+     */
+    async convertToPCM(filePath: string, pcmPath: string): Promise<Buffer> {
+        const addon = this.ensureAddon();
+        const result = await addon.decodeAudioToPCM(filePath);
+
+        // 写入文件
+        await writeFile(pcmPath, result.pcm);
+
+        return result.pcm;
+    }
+
+    /**
+     * 转换文件
+     */
+    async convertFile(inputFile: string, outputFile: string, format: string): Promise<void> {
+        const addon = this.ensureAddon();
+
+        if (format === 'silk' || format === 'ntsilk') {
+            // 使用 Addon 的 NTSILK 转换
+            await addon.convertToNTSilkTct(inputFile, outputFile);
+        } else {
+            throw new Error(`Format '${format}' is not supported by FFmpeg Addon`);
+        }
+    }
+
+    /**
+     * 提取缩略图
+     */
+    async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
+        const addon = this.ensureAddon();
+        const info = await addon.getVideoInfo(videoPath);
+
+        // 将缩略图写入文件
+        await writeFile(thumbnailPath, info.image);
+    }
+}

src/common/ffmpeg-addon.ts

@@ -0,0 +1,71 @@
+/**
+ * FFmpeg Node.js Native Addon Type Definitions
+ * 
+ * This addon provides FFmpeg functionality for Node.js including:
+ * - Video information extraction with thumbnail generation
+ * - Audio/Video duration detection
+ * - Audio format conversion to NTSILK
+ * - Audio decoding to PCM
+ */
+
+/**
+ * Video information result object
+ */
+export interface VideoInfo {
+    /** Video width in pixels */
+    width: number;
+
+    /** Video height in pixels */
+    height: number;
+
+    /** Video duration in seconds */
+    duration: number;
+
+    /** Container format name (e.g., "mp4", "mkv", "avi") */
+    format: string;
+
+    /** Video codec name (e.g., "h264", "hevc", "vp9") */
+    videoCodec: string;
+
+    /** First frame thumbnail as BMP image buffer */
+    image: Buffer;
+}
+
+/**
+ * Audio PCM decoding result object
+ */
+export interface AudioPCMResult {
+    /** PCM audio data as 16-bit signed integer samples */
+    pcm: Buffer;
+
+    /** Sample rate in Hz (e.g., 44100, 48000, 24000) */
+    sampleRate: number;
+
+    /** Number of audio channels (1 for mono, 2 for stereo) */
+    channels: number;
+}
+
+/**
+ * FFmpeg interface providing all audio/video processing methods
+ */
+export interface FFmpeg {
+    /**
+     * Get video information including resolution, duration, format, codec and first frame thumbnail
+     */
+    getVideoInfo(filePath: string, format?: 'bmp' | 'bmp24'): Promise<VideoInfo>;
+
+    /**
+     * Get duration of audio or video file in seconds
+     */
+    getDuration(filePath: string): Promise<number>;
+
+    /**
+     * Convert audio file to NTSILK format (WeChat voice message format)
+     */
+    convertToNTSilkTct(inputPath: string, outputPath: string): Promise<void>;
+
+    /**
+     * Decode audio file to raw PCM data
+     */
+    decodeAudioToPCM(filePath: string): Promise<AudioPCMResult>;
+}

src/common/ffmpeg-exec-adapter.ts

@@ -0,0 +1,244 @@
+/**
+ * FFmpeg Exec Adapter
+ * 使用 execFile 调用 FFmpeg 命令行工具的适配器实现
+ */
+
+import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { fileTypeFromFile } from 'file-type';
+import { imageSizeFallBack } from '@/image-size';
+import { downloadFFmpegIfNotExists } from './download-ffmpeg';
+import { LogWrapper } from './log';
+import type { IFFmpegAdapter, VideoInfoResult } from './ffmpeg-adapter-interface';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * 确保目录存在
+ */
+function ensureDirExists(filePath: string): void {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+
+/**
+ * FFmpeg 命令行适配器实现
+ */
+export class FFmpegExecAdapter implements IFFmpegAdapter {
+    public readonly name = 'FFmpegExec';
+    private downloadAttempted = false;
+    
+    constructor(
+        private ffmpegPath: string = 'ffmpeg',
+        private ffprobePath: string = 'ffprobe',
+        private binaryPath?: string,
+        private logger?: LogWrapper
+    ) {}
+
+    /**
+     * 检查 FFmpeg 是否可用，如果不可用则尝试下载
+     */
+    async isAvailable(): Promise<boolean> {
+        // 首先检查当前路径
+        try {
+            await execFileAsync(this.ffmpegPath, ['-version']);
+            return true;
+        } catch {
+            // 如果失败且未尝试下载，尝试下载
+            if (!this.downloadAttempted && this.binaryPath && this.logger) {
+                this.downloadAttempted = true;
+                
+                if (process.env['NAPCAT_DISABLE_FFMPEG_DOWNLOAD']) {
+                    return false;
+                }
+                
+                this.logger.log('[FFmpeg] 未找到可用的 FFmpeg，尝试自动下载...');
+                const result = await downloadFFmpegIfNotExists(this.logger);
+                
+                if (result.path && result.reset) {
+                    // 更新路径
+                    if (process.platform === 'win32') {
+                        this.ffmpegPath = join(result.path, 'ffmpeg.exe');
+                        this.ffprobePath = join(result.path, 'ffprobe.exe');
+                        this.logger.log('[FFmpeg] 已更新路径:', this.ffmpegPath);
+                        
+                        // 再次检查
+                        try {
+                            await execFileAsync(this.ffmpegPath, ['-version']);
+                            return true;
+                        } catch {
+                            return false;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+    }
+
+    /**
+     * 设置 FFmpeg 路径
+     */
+    setFFmpegPath(ffmpegPath: string): void {
+        this.ffmpegPath = ffmpegPath;
+    }
+
+    /**
+     * 设置 FFprobe 路径
+     */
+    setFFprobePath(ffprobePath: string): void {
+        this.ffprobePath = ffprobePath;
+    }
+
+    /**
+     * 获取视频信息
+     */
+    async getVideoInfo(videoPath: string): Promise<VideoInfoResult> {
+        // 获取文件大小和类型
+        const [fileType, duration] = await Promise.all([
+            fileTypeFromFile(videoPath).catch(() => null),
+            this.getDuration(videoPath)
+        ]);
+
+        // 创建临时缩略图路径
+        const thumbnailPath = `${videoPath}.thumbnail.bmp`;
+        let width = 100;
+        let height = 100;
+        let thumbnail: Buffer | undefined;
+
+        try {
+            await this.extractThumbnail(videoPath, thumbnailPath);
+            
+            // 获取图片尺寸
+            const dimensions = await imageSizeFallBack(thumbnailPath);
+            width = dimensions.width ?? 100;
+            height = dimensions.height ?? 100;
+            
+            // 读取缩略图
+            if (existsSync(thumbnailPath)) {
+                thumbnail = readFileSync(thumbnailPath);
+            }
+        } catch (error) {
+            // 使用默认值
+        }
+
+        return {
+            width,
+            height,
+            duration,
+            format: fileType?.ext ?? 'mp4',
+            thumbnail,
+        };
+    }
+
+    /**
+     * 获取时长
+     */
+    async getDuration(filePath: string): Promise<number> {
+        try {
+            const { stdout } = await execFileAsync(this.ffprobePath, [
+                '-v', 'error',
+                '-show_entries', 'format=duration',
+                '-of', 'default=noprint_wrappers=1:nokey=1',
+                filePath
+            ]);
+
+            const duration = parseFloat(stdout.trim());
+            return isNaN(duration) ? 60 : duration;
+        } catch {
+            return 60; // 默认时长
+        }
+    }
+
+    /**
+     * 转换为 PCM
+     */
+    async convertToPCM(filePath: string, pcmPath: string): Promise<Buffer> {
+        try {
+            ensureDirExists(pcmPath);
+
+            await execFileAsync(this.ffmpegPath, [
+                '-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}`);
+        }
+    }
+
+    /**
+     * 转换文件
+     */
+    async convertFile(inputFile: string, outputFile: string, format: string): Promise<void> {
+        try {
+            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(this.ffmpegPath, params);
+
+            if (!existsSync(outputFile)) {
+                throw new Error('转换失败,输出文件不存在');
+            }
+        } catch (error) {
+            console.error('Error converting file:', error);
+            throw new Error(`文件转换失败: ${(error as Error).message}`);
+        }
+    }
+
+    /**
+     * 提取缩略图
+     */
+    async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
+        try {
+            ensureDirExists(thumbnailPath);
+
+            const { stderr } = await execFileAsync(this.ffmpegPath, [
+                '-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}`);
+        }
+    }
+}

src/common/ffmpeg.ts

@@ -1,195 +1,144 @@
-import { readFileSync, statSync, existsSync, mkdirSync } from 'fs';
-import path, { dirname } from 'path';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import { statSync, existsSync, writeFileSync } from 'fs';
+import path from 'path';
 import type { VideoInfo } from './video';
 import { fileTypeFromFile } from 'file-type';
-import { fileURLToPath } from 'node:url';
 import { platform } from 'node:os';
 import { LogWrapper } from './log';
-import { imageSizeFallBack } from '@/image-size';
-const currentPath = dirname(fileURLToPath(import.meta.url));
-const execFileAsync = promisify(execFile);
-const getFFmpegPath = (tool: string): string => {
-    if (process.platform === 'win32') {
+import { FFmpegAdapterFactory } from './ffmpeg-adapter-factory';
+import type { IFFmpegAdapter } from './ffmpeg-adapter-interface';
+
+const getFFmpegPath = (tool: string, binaryPath?: string): string => {
+    if (process.platform === 'win32' && binaryPath) {
         const exeName = `${tool}.exe`;
-        const isLocalExeExists = existsSync(path.join(currentPath, 'ffmpeg', exeName));
-        return isLocalExeExists ? path.join(currentPath, 'ffmpeg', exeName) : exeName;
+        const localPath = path.join(binaryPath, 'ffmpeg', exeName);
+        const isLocalExeExists = existsSync(localPath);
+        return isLocalExeExists ? localPath : exeName;
     }
     return tool;
 };
-export let FFMPEG_CMD = getFFmpegPath('ffmpeg');
-export let FFPROBE_CMD = getFFmpegPath('ffprobe');
+
+export let FFMPEG_CMD = 'ffmpeg';
+export let FFPROBE_CMD = 'ffprobe';
 export class FFmpegService {
-    // 确保目标目录存在
-    public static setFfmpegPath(ffmpegPath: string,logger:LogWrapper): void {
+    private static adapter: IFFmpegAdapter | null = null;
+    private static initialized = false;
+
+    /**
+     * 初始化 FFmpeg 服务
+     * @param binaryPath 二进制文件路径(来自 pathWrapper.binaryPath)
+     * @param logger 日志记录器
+     */
+    public static async init(binaryPath: string, logger: LogWrapper): Promise<void> {
+        if (this.initialized) {
+            return;
+        }
+
+        // 检查本地 ffmpeg 路径
+        FFMPEG_CMD = getFFmpegPath('ffmpeg', binaryPath);
+        FFPROBE_CMD = getFFmpegPath('ffprobe', binaryPath);
+
+        // 立即初始化适配器(会触发自动下载等逻辑)
+        this.adapter = await FFmpegAdapterFactory.getAdapter(
+            logger,
+            FFMPEG_CMD,
+            FFPROBE_CMD,
+            binaryPath
+        );
+
+        this.initialized = true;
+    }
+
+    /**
+     * 获取 FFmpeg 适配器
+     */
+    private static async getAdapter(): Promise<IFFmpegAdapter> {
+        if (!this.adapter) {
+            throw new Error('FFmpeg service not initialized. Please call FFmpegService.init() first.');
+        }
+        return this.adapter;
+    }
+
+    /**
+     * 设置 FFmpeg 路径并更新适配器
+     * @deprecated 建议使用 init() 方法初始化
+     */
+    public static async setFfmpegPath(ffmpegPath: string, logger: LogWrapper): Promise<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 });
+
+            // 更新适配器路径
+            await FFmpegAdapterFactory.updateFFmpegPath(logger, FFMPEG_CMD, FFPROBE_CMD);
         }
     }
 
+    /**
+     * 提取视频缩略图
+     */
     public static async extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void> {
-        try {
-            this.ensureDirExists(thumbnailPath);
-
-            const { stderr } = await execFileAsync(FFMPEG_CMD, [
-                '-i', videoPath,
-                '-ss', '00:00:01.000',
-                '-vframes', '1',
-                '-y', // 覆盖输出文件
-                thumbnailPath
-            ]);
-
-            if (!existsSync(thumbnailPath)) {
-                throw new Error(`提取缩略图失败，输出文件不存在: ${stderr}`);
-            }
-        } catch (error) {
-            console.error('Error extracting thumbnail:', error);
-            throw new Error(`提取缩略图失败: ${(error as Error).message}`);
-        }
+        const adapter = await this.getAdapter();
+        await adapter.extractThumbnail(videoPath, thumbnailPath);
     }
 
+    /**
+     * 转换音频文件
+     */
     public static async convertFile(inputFile: string, outputFile: string, format: string): Promise<void> {
-        try {
-            this.ensureDirExists(outputFile);
-
-            const params = format === 'amr'
-                ? [
-                    '-f', 's16le',
-                    '-ar', '24000',
-                    '-ac', '1',
-                    '-i', inputFile,
-                    '-ar', '8000',
-                    '-b:a', '12.2k',
-                    '-y',
-                    outputFile
-                ]
-                : [
-                    '-f', 's16le',
-                    '-ar', '24000',
-                    '-ac', '1',
-                    '-i', inputFile,
-                    '-y',
-                    outputFile
-                ];
-
-            await execFileAsync(FFMPEG_CMD, params);
-
-            if (!existsSync(outputFile)) {
-                throw new Error('转换失败，输出文件不存在');
-            }
-        } catch (error) {
-            console.error('Error converting file:', error);
-            throw new Error(`文件转换失败: ${(error as Error).message}`);
-        }
+        const adapter = await this.getAdapter();
+        await adapter.convertFile(inputFile, outputFile, format);
     }
 
+    /**
+     * 转换为 PCM 格式
+     */
     public static async convert(filePath: string, pcmPath: string): Promise<Buffer> {
-        try {
-            this.ensureDirExists(pcmPath);
-
-            await execFileAsync(FFMPEG_CMD, [
-                '-y',
-                '-i', filePath,
-                '-ar', '24000',
-                '-ac', '1',
-                '-f', 's16le',
-                pcmPath
-            ]);
-
-            if (!existsSync(pcmPath)) {
-                throw new Error('转换PCM失败，输出文件不存在');
-            }
-
-            return readFileSync(pcmPath);
-        } catch (error: any) {
-            throw new Error(`FFmpeg处理转换出错: ${error.message}`);
-        }
+        const adapter = await this.getAdapter();
+        return adapter.convertToPCM(filePath, pcmPath);
     }
 
+    /**
+     * 获取视频信息
+     */
     public static async getVideoInfo(videoPath: string, thumbnailPath: string): Promise<VideoInfo> {
+        const adapter = await this.getAdapter();
+
         try {
-            // 并行执行获取文件信息和提取缩略图
-            const [fileInfo, duration] = await Promise.all([
-                this.getFileInfo(videoPath, thumbnailPath),
-                this.getVideoDuration(videoPath)
-            ]);
+            // 获取文件大小
+            const fileSize = statSync(videoPath).size;
+
+            // 使用适配器获取视频信息
+            const videoInfo = await adapter.getVideoInfo(videoPath);
+
+            // 如果提供了缩略图路径且适配器返回了缩略图,保存到指定路径
+            if (thumbnailPath && videoInfo.thumbnail) {
+                writeFileSync(thumbnailPath, videoInfo.thumbnail);
+            }
 
             const result: VideoInfo = {
-                width: fileInfo.width,
-                height: fileInfo.height,
-                time: duration,
-                format: fileInfo.format,
-                size: fileInfo.size,
+                width: videoInfo.width,
+                height: videoInfo.height,
+                time: videoInfo.duration,
+                format: videoInfo.format,
+                size: fileSize,
                 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 = await imageSizeFallBack(thumbnailPath);
+            // 降级处理:返回默认值
+            const fileType = await fileTypeFromFile(videoPath).catch(() => null);
+            const fileSize = statSync(videoPath).size;
 
             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
+                height: 100,
+                time: 60,
+                format: fileType?.ext ?? 'mp4',
+                size: fileSize,
+                filePath: videoPath
             };
         }
     }
-
-    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/health.ts

@@ -9,41 +9,50 @@ export interface ResourceConfig<T extends any[], R> {
     healthCheckInterval?: number;
     /** 最大健康检查失败次数，超过后永久禁用，默认 5 次 */
     maxHealthCheckFailures?: number;
-    /** 资源名称（用于日志） */
-    name?: string;
-    /** 测试参数（用于健康检查） */
-    testArgs?: T;
     /** 健康检查函数，如果提供则优先使用此函数进行健康检查 */
     healthCheckFn?: (...args: T) => Promise<boolean>;
+    /** 测试参数（用于健康检查） */
+    testArgs?: T;
 }
 
-interface ResourceState<T extends any[], R> {
-    config: ResourceConfig<T, R>;
+interface ResourceTypeState {
+    /** 资源配置 */
+    config: {
+        resourceFn: (...args: any[]) => Promise<any>;
+        healthCheckFn?: (...args: any[]) => Promise<boolean>;
+        disableTime: number;
+        maxRetries: number;
+        healthCheckInterval: number;
+        maxHealthCheckFailures: number;
+        testArgs?: any[];
+    };
+    /** 是否启用 */
     isEnabled: boolean;
+    /** 禁用截止时间 */
     disableUntil: number;
+    /** 当前重试次数 */
     currentRetries: number;
+    /** 健康检查失败次数 */
     healthCheckFailureCount: number;
+    /** 是否永久禁用 */
     isPermanentlyDisabled: boolean;
-    lastError?: Error;
+    /** 上次健康检查时间 */
     lastHealthCheckTime: number;
-    registrationKey: string;
+    /** 成功次数统计 */
+    successCount: number;
+    /** 失败次数统计 */
+    failureCount: number;
 }
 
 export class ResourceManager {
-    private resources = new Map<string, ResourceState<any, any>>();
+    private resourceTypes = new Map<string, ResourceTypeState>();
     private destroyed = false;
-    private healthCheckTimer?: NodeJS.Timeout;
-    private readonly HEALTH_CHECK_TASK_INTERVAL = 5000; // 5秒执行一次健康检查任务
-
-    constructor() {
-        this.startHealthCheckTask();
-    }
 
     /**
-     * 注册资源（注册即调用，重复注册只实际注册一次）
+     * 调用资源（自动注册或复用已有配置）
      */
-    async register<T extends any[], R>(
-        key: string,
+    async callResource<T extends any[], R>(
+        type: string,
         config: ResourceConfig<T, R>,
         ...args: T
     ): Promise<R> {
@@ -51,81 +60,64 @@ export class ResourceManager {
             throw new Error('ResourceManager has been destroyed');
         }
 
-        const registrationKey = this.generateRegistrationKey(key, config);
+        // 获取或创建资源类型状态
+        let state = this.resourceTypes.get(type);
 
-        // 检查是否已经注册
-        if (this.resources.has(key)) {
-            const existingState = this.resources.get(key)!;
-
-            // 如果是相同的配置，直接调用
-            if (existingState.registrationKey === registrationKey) {
-                return this.callResource<T, R>(key, ...args);
-            }
-
-            // 配置不同，清理旧的并重新注册
-            this.unregister(key);
-        }
-
-        // 创建新的资源状态
-        const state: ResourceState<T, R> = {
-            config: {
-                disableTime: 30000,
-                maxRetries: 3,
-                healthCheckInterval: 60000,
-                maxHealthCheckFailures: 5,
-                name: key,
-                ...config
-            },
-            isEnabled: true,
-            disableUntil: 0,
-            currentRetries: 0,
-            healthCheckFailureCount: 0,
-            isPermanentlyDisabled: false,
-            lastHealthCheckTime: 0,
-            registrationKey
-        };
-
-        this.resources.set(key, state);
-
-        // 注册即调用
-        return await this.callResource<T, R>(key, ...args);
-    }
-
-    /**
-     * 调用资源
-     */
-    async callResource<T extends any[], R>(key: string, ...args: T): Promise<R> {
-        const state = this.resources.get(key) as ResourceState<T, R> | undefined;
         if (!state) {
-            throw new Error(`Resource ${key} not registered`);
+            // 首次注册
+            state = {
+                config: {
+                    resourceFn: config.resourceFn as (...args: any[]) => Promise<any>,
+                    healthCheckFn: config.healthCheckFn as ((...args: any[]) => Promise<boolean>) | undefined,
+                    disableTime: config.disableTime ?? 30000,
+                    maxRetries: config.maxRetries ?? 3,
+                    healthCheckInterval: config.healthCheckInterval ?? 60000,
+                    maxHealthCheckFailures: config.maxHealthCheckFailures ?? 20,
+                    testArgs: config.testArgs as any[] | undefined,
+                },
+                isEnabled: true,
+                disableUntil: 0,
+                currentRetries: 0,
+                healthCheckFailureCount: 0,
+                isPermanentlyDisabled: false,
+                lastHealthCheckTime: 0,
+                successCount: 0,
+                failureCount: 0,
+            };
+            this.resourceTypes.set(type, state);
         }
 
+        // 在调用前检查是否需要进行健康检查
+        await this.checkAndPerformHealthCheck(state);
+
+        // 检查资源状态
         if (state.isPermanentlyDisabled) {
-            throw new Error(`Resource ${key} is permanently disabled due to repeated health check failures`);
+            throw new Error(`Resource type '${type}' is permanently disabled (success: ${state.successCount}, failure: ${state.failureCount})`);
         }
 
-        if (!this.isResourceAvailable(key)) {
+        if (!this.isResourceAvailable(type)) {
             const disableUntilDate = new Date(state.disableUntil).toISOString();
-            throw new Error(`Resource ${key} is currently disabled until ${disableUntilDate}`);
+            throw new Error(`Resource type '${type}' is currently disabled until ${disableUntilDate} (success: ${state.successCount}, failure: ${state.failureCount})`);
         }
 
+        // 调用资源
         try {
-            const result = await state.config.resourceFn(...args);
+            const result = await config.resourceFn(...args);
             this.onResourceSuccess(state);
             return result;
         } catch (error) {
-            this.onResourceFailure(state, error as Error);
+            this.onResourceFailure(state);
             throw error;
         }
     }
 
     /**
-     * 检查资源是否可用
+     * 检查资源类型是否可用
      */
-    isResourceAvailable(key: string): boolean {
-        const state = this.resources.get(key);
+    isResourceAvailable(type: string): boolean {
+        const state = this.resourceTypes.get(type);
         if (!state) {
-            return false;
+            return true; // 未注册的资源类型视为可用
         }
 
         if (state.isPermanentlyDisabled || !state.isEnabled) {
@@ -136,128 +128,97 @@ export class ResourceManager {
     }
 
     /**
-     * 注销资源
+     * 获取资源类型统计信息
      */
-    unregister(key: string): boolean {
-        return this.resources.delete(key);
+    getResourceStats(type: string): { successCount: number; failureCount: number; isEnabled: boolean; isPermanentlyDisabled: boolean } | null {
+        const state = this.resourceTypes.get(type);
+        if (!state) {
+            return null;
+        }
+
+        return {
+            successCount: state.successCount,
+            failureCount: state.failureCount,
+            isEnabled: state.isEnabled,
+            isPermanentlyDisabled: state.isPermanentlyDisabled,
+        };
     }
 
     /**
-     * 销毁管理器，清理所有资源
+     * 获取所有资源类型统计
+     */
+    getAllResourceStats(): Map<string, { successCount: number; failureCount: number; isEnabled: boolean; isPermanentlyDisabled: boolean }> {
+        const stats = new Map();
+        for (const [type, state] of this.resourceTypes) {
+            stats.set(type, {
+                successCount: state.successCount,
+                failureCount: state.failureCount,
+                isEnabled: state.isEnabled,
+                isPermanentlyDisabled: state.isPermanentlyDisabled,
+            });
+        }
+        return stats;
+    }
+
+    /**
+     * 注销资源类型
+     */
+    unregister(type: string): boolean {
+        return this.resourceTypes.delete(type);
+    }
+
+    /**
+     * 销毁管理器
      */
     destroy(): void {
         if (this.destroyed) {
             return;
         }
 
-        this.stopHealthCheckTask();
-        this.resources.clear();
+        this.resourceTypes.clear();
         this.destroyed = true;
     }
 
-    private generateRegistrationKey<T extends any[], R>(key: string, config: ResourceConfig<T, R>): string {
-        const configStr = JSON.stringify({
-            name: config.name,
-            disableTime: config.disableTime,
-            maxRetries: config.maxRetries,
-            healthCheckInterval: config.healthCheckInterval,
-            maxHealthCheckFailures: config.maxHealthCheckFailures,
-            functionStr: config.resourceFn.toString(),
-            healthCheckFnStr: config.healthCheckFn?.toString()
-        });
-
-        return `${key}_${this.simpleHash(configStr)}`;
-    }
-
-    private simpleHash(str: string): string {
-        let hash = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str.charCodeAt(i);
-            hash = ((hash << 5) - hash) + char;
-            hash = hash & hash; // Convert to 32bit integer
-        }
-        return Math.abs(hash).toString(36);
-    }
-
-    private onResourceSuccess<T extends any[], R>(state: ResourceState<T, R>): void {
-        state.currentRetries = 0;
-        state.disableUntil = 0;
-        state.healthCheckFailureCount = 0;
-        state.lastError = undefined;
-    }
-
-    private onResourceFailure<T extends any[], R>(state: ResourceState<T, R>, error: Error): void {
-        state.currentRetries++;
-        state.lastError = error;
-
-        // 如果重试次数达到上限，禁用资源
-        if (state.currentRetries >= state.config.maxRetries!) {
-            state.disableUntil = Date.now() + state.config.disableTime!;
-            state.currentRetries = 0;
-        }
-    }
-
-    private startHealthCheckTask(): void {
-        if (this.healthCheckTimer) {
+    /**
+     * 检查并执行健康检查（如果需要）
+     */
+    private async checkAndPerformHealthCheck(state: ResourceTypeState): Promise<void> {
+        // 如果资源可用或已永久禁用，无需健康检查
+        if (state.isEnabled && Date.now() >= state.disableUntil) {
             return;
         }
 
-        this.healthCheckTimer = setInterval(() => {
-            this.runHealthCheckTask();
-        }, this.HEALTH_CHECK_TASK_INTERVAL);
-    }
-
-    private stopHealthCheckTask(): void {
-        if (this.healthCheckTimer) {
-            clearInterval(this.healthCheckTimer);
-            this.healthCheckTimer = undefined;
-        }
-    }
-
-    private async runHealthCheckTask(): Promise<void> {
-        if (this.destroyed) {
+        if (state.isPermanentlyDisabled) {
             return;
         }
 
         const now = Date.now();
 
-        for (const [key, state] of this.resources) {
-            // 跳过永久禁用或可用的资源
-            if (state.isPermanentlyDisabled || this.isResourceAvailable(key)) {
-                continue;
-            }
-
-            // 跳过还在禁用期内的资源
-            if (now < state.disableUntil) {
-                continue;
-            }
-
-            // 检查是否需要进行健康检查（根据间隔时间）
-            const lastHealthCheck = state.lastHealthCheckTime || 0;
-            const healthCheckInterval = state.config.healthCheckInterval!;
-
-            if (now - lastHealthCheck < healthCheckInterval) {
-                continue;
-            }
-
-            // 执行健康检查
-            await this.performHealthCheck(state);
+        // 检查是否还在禁用期内
+        if (now < state.disableUntil) {
+            return;
         }
+
+        // 检查是否需要进行健康检查（根据间隔时间）
+        if (now - state.lastHealthCheckTime < state.config.healthCheckInterval) {
+            return;
+        }
+
+        // 执行健康检查
+        await this.performHealthCheck(state);
     }
 
-    private async performHealthCheck<T extends any[], R>(state: ResourceState<T, R>): Promise<void> {
+    private async performHealthCheck(state: ResourceTypeState): Promise<void> {
         state.lastHealthCheckTime = Date.now();
 
         try {
             let healthCheckResult: boolean;
 
-            // 如果有专门的健康检查函数，使用它
             if (state.config.healthCheckFn) {
-                const testArgs = state.config.testArgs || [] as unknown as T;
+                const testArgs = state.config.testArgs || [];
                 healthCheckResult = await state.config.healthCheckFn(...testArgs);
             } else {
-                // 否则使用原始函数进行检查
-                const testArgs = state.config.testArgs || [] as unknown as T;
+                const testArgs = state.config.testArgs || [];
                 await state.config.resourceFn(...testArgs);
                 healthCheckResult = true;
             }
@@ -268,26 +229,42 @@ export class ResourceManager {
                 state.disableUntil = 0;
                 state.currentRetries = 0;
                 state.healthCheckFailureCount = 0;
-                state.lastError = undefined;
             } else {
                 throw new Error('Health check function returned false');
             }
-        } catch (error) {
+        } catch {
             // 健康检查失败，增加失败计数
             state.healthCheckFailureCount++;
-            state.lastError = error as Error;
 
             // 检查是否达到最大健康检查失败次数
-            if (state.healthCheckFailureCount >= state.config.maxHealthCheckFailures!) {
+            if (state.healthCheckFailureCount >= state.config.maxHealthCheckFailures) {
                 // 永久禁用资源
                 state.isPermanentlyDisabled = true;
                 state.disableUntil = 0;
             } else {
                 // 继续禁用一段时间
-                state.disableUntil = Date.now() + state.config.disableTime!;
+                state.disableUntil = Date.now() + state.config.disableTime;
             }
         }
     }
+
+    private onResourceSuccess(state: ResourceTypeState): void {
+        state.currentRetries = 0;
+        state.disableUntil = 0;
+        state.healthCheckFailureCount = 0;
+        state.successCount++;
+    }
+
+    private onResourceFailure(state: ResourceTypeState): void {
+        state.currentRetries++;
+        state.failureCount++;
+
+        // 如果重试次数达到上限，禁用资源
+        if (state.currentRetries >= state.config.maxRetries) {
+            state.disableUntil = Date.now() + state.config.disableTime;
+            state.currentRetries = 0;
+        }
+    }
 }
 
 // 创建全局实例
@@ -295,34 +272,9 @@ export const resourceManager = new ResourceManager();
 
 // 便捷函数
 export async function registerResource<T extends any[], R>(
-    key: string,
+    type: string,
     config: ResourceConfig<T, R>,
     ...args: T
 ): Promise<R> {
-    return resourceManager.register(key, config, ...args);
-}
-
-// 使用示例：
-/*
-await registerResource(
-  'api-with-health-check',
-  {
-    resourceFn: async (id: string) => {
-      const response = await fetch(`https://api.example.com/data/${id}`);
-      return response.json();
-    },
-    healthCheckFn: async (id: string) => {
-      try {
-        const response = await fetch(`https://api.example.com/health`);
-        return response.ok;
-      } catch {
-        return false;
-      }
-    },
-    testArgs: ['health-check-id'],
-    healthCheckInterval: 30000,
-    maxHealthCheckFailures: 3
-  },
-  'user123'
-);
-*/
+    return resourceManager.callResource(type, config, ...args);
+}

src/common/helper.ts

@@ -163,8 +163,10 @@ export function getQQVersionConfigPath(exePath: string = ''): string | undefined
 
 export function calcQQLevel(level?: QQLevel) {
     if (!level) return 0;
-    const { crownNum, sunNum, moonNum, starNum } = level;
-    return crownNum * 64 + sunNum * 16 + moonNum * 4 + starNum;
+    //const { penguinNum, crownNum, sunNum, moonNum, starNum } = level;
+    const { crownNum, sunNum, moonNum, starNum } = level
+    //没补类型
+    return   crownNum * 64 + sunNum * 16 + moonNum * 4 + starNum;
 }
 
 export function stringifyWithBigInt(obj: any) {
@@ -204,4 +206,4 @@ export function parseAppidFromMajor(nodeMajor: string): string | undefined {
     }
 
     return undefined;
-}
+}

src/common/qq-basic-info.ts

@@ -39,7 +39,7 @@ export class QQBasicInfoWrapper {
 
     //基础函数
     getQQBuildStr() {
-        return this.isQuickUpdate ? this.QQVersionConfig?.buildId : this.QQPackageInfo?.buildVersion;
+        return this.QQVersionConfig?.curVersion.split('-')[1] ?? this.QQPackageInfo?.buildVersion;
     }
 
     getFullQQVersion() {

src/common/version.ts

@@ -1 +1 @@
-export const napCatVersion = '4.8.109';
+export const napCatVersion = '4.9.4';

src/core/apis/file.ts

@@ -64,7 +64,7 @@ export class NTQQFileApi {
         }
     }
 
-    async getFileUrl(chatType: ChatType, peer: string, fileUUID?: string, file10MMd5?: string | undefined,timeout: number = 20000) {
+    async getFileUrl(chatType: ChatType, peer: string, fileUUID?: string, file10MMd5?: string | undefined,timeout: number = 5000) {
         if (this.core.apis.PacketApi.packetStatus) {
             try {
                 if (chatType === ChatType.KCHATTYPEGROUP && fileUUID) {
@@ -79,7 +79,7 @@ export class NTQQFileApi {
         throw new Error('fileUUID or file10MMd5 is undefined');
     }
 
-    async getPttUrl(peer: string, fileUUID?: string,timeout: number = 20000) {
+    async getPttUrl(peer: string, fileUUID?: string,timeout: number = 5000) {
         if (this.core.apis.PacketApi.packetStatus && fileUUID) {
             let appid = new NapProtoMsg(FileId).decode(Buffer.from(fileUUID.replaceAll('-', '+').replaceAll('_', '/'), 'base64')).appid;
             try {
@@ -107,7 +107,7 @@ export class NTQQFileApi {
         throw new Error('packet cant get ptt url');
     }
 
-    async getVideoUrlPacket(peer: string, fileUUID?: string,timeout: number = 20000) {
+    async getVideoUrlPacket(peer: string, fileUUID?: string,timeout: number = 5000) {
         if (this.core.apis.PacketApi.packetStatus && fileUUID) {
             let appid = new NapProtoMsg(FileId).decode(Buffer.from(fileUUID.replaceAll('-', '+').replaceAll('_', '/'), 'base64')).appid;
             try {

src/core/apis/group.ts

@@ -49,7 +49,6 @@ export class NTQQGroupApi {
     async initApi() {
         this.initCache().then().catch(e => this.context.logger.logError(e));
     }
-
     async createGrayTip(groupCode: string, tip: string) {
         return this.context.session.getMsgService().addLocalJsonGrayTipMsg(
             {

src/core/apis/packet.ts

@@ -1,5 +1,5 @@
 import * as os from 'os';
-import offset from '@/core/external/offset.json';
+import offset from '@/core/external/napi2native.json';
 import { InstanceContext, NapCatCore } from '@/core';
 import { LogWrapper } from '@/common/log';
 import { PacketClientSession } from '@/core/packet/clientSession';

src/core/external/appid.json

@@ -386,5 +386,45 @@
     "9.9.21-39038": {
         "appid": 537313906,
         "qua": "V1_WIN_NQ_9.9.21_39038_GW_B"
+    },
+    "9.9.22-40362": {
+        "appid": 537314212,
+        "qua": "V1_WIN_NQ_9.9.22_40362_GW_B"
+    },
+    "3.2.20-40768": {
+        "appid": 537319840,
+        "qua": "V1_LNX_NQ_3.2.20_40768_GW_B"
+    },
+    "9.9.22-40768": {
+        "appid": 537319804,
+        "qua": "V1_WIN_NQ_9.9.22_40768_GW_B"
+    },
+    "6.9.82-40768": {
+        "appid": 537319829,
+        "qua": "V1_MAC_NQ_6.9.82_40768_GW_B"
+    },
+    "3.2.20-40824": {
+        "appid": 537319840,
+        "qua": "V1_LNX_NQ_3.2.20_40824_GW_B"
+    },
+    "9.9.22-40824": {
+        "appid": 537319804,
+        "qua": "V1_WIN_NQ_9.9.22_40824_GW_B"
+    },
+    "6.9.82-40824": {
+        "appid": 537319829,
+        "qua": "V1_MAC_NQ_6.9.82_40824_GW_B"
+    },
+    "6.9.82-40990": {
+        "appid": 537319880,
+        "qua": "V1_MAC_NQ_6.9.82_40990_GW_B"
+    },
+    "9.9.22-40990": {
+        "appid": 537319855,
+        "qua": "V1_WIN_NQ_9.9.22.40990_GW_B"
+    },
+    "3.2.20-40990": {
+        "appid": 537319891,
+        "qua": "V1_LNX_NQ_3.2.20_40990_GW_B"
     }
 }

src/core/external/napi2native.json

@@ -0,0 +1,38 @@
+{
+    "9.9.22-40990-x64": {
+        "send": "1B5699C",
+        "recv": "1D8CA9D"
+    },
+    "9.9.22-40824-x64": {
+        "send": "1B5699C",
+        "recv": "1D8CA9D"
+    },
+    "9.9.22-40768-x64": {
+        "send": "1B5699C",
+        "recv": "1D8CA9D"
+    },
+    "3.2.20-40768-x64": {
+        "send": "2A1B840",
+        "recv": "2D28F20"
+    },
+    "3.2.20-40824-x64": {
+        "send": "2A1B840",
+        "recv": "2D28F20"
+    },
+    "3.2.20-40990-x64": {
+        "send": "2A1B840",
+        "recv": "2D28F20"
+    },
+    "3.2.20-40990-arm64": {
+        "send": "157C0E8",
+        "recv": "1546658"
+    },
+    "3.2.20-40824-arm64": {
+        "send": "157C0E8",
+        "recv": "1546658"
+    },
+    "3.2.20-40768-arm64": {
+        "send": "157C0E8",
+        "recv": "1546658"
+    }
+}

src/core/external/packet.json

@@ -507,8 +507,56 @@
         "send": "7B025C8",
         "recv": "7B05F58"
     },
-     "9.9.21-39038-x64": {
+    "9.9.21-39038-x64": {
         "send": "313FB58",
         "recv": "31432FC"
+    },
+    "9.9.22-40362-x64": {
+        "send": "31C0EB8",
+        "recv": "31C465C"
+    },
+    "3.2.20-40768-x64": {
+        "send": "B69CFE0",
+        "recv": "B6A0A60"
+    },
+    "9.9.22-40768-x64": {
+        "send": "31C1838",
+        "recv": "31C4FDC"
+    },
+    "3.2.20-40768-arm64": {
+        "send": "7D49B18",
+        "recv": "7D4D4A8"
+    },
+    "6.9.82-40768-arm64": {
+        "send": "202A198",
+        "recv": "202B718"
+    },
+    "9.9.22-40824-x64": {
+        "send": "31C1838",
+        "recv": "31C4FDC"
+    },
+    "3.2.20-40824-arm64": {
+        "send": "7D49B18",
+        "recv": "7D4D4A8"
+    },
+    "6.9.82-40824-arm64": {
+        "send": "202A198",
+        "recv": "202B718"
+    },
+    "3.2.20-40990-x64": {
+        "send": "B69CFE0",
+        "recv": "B6A0A60"
+    },
+    "3.2.20-40990-arm64": {
+        "send": "7D49B18",
+        "recv": "7D4D4A8"
+    },
+    "9.9.22-40990-x64": {
+        "send": "31C1838",
+        "recv": "31C4FDC"
+    },
+    "6.9.82-40990-arm64": {
+        "send": "202A198",
+        "recv": "202B718"
     }
 }

src/core/index.ts

@@ -30,6 +30,7 @@ import os from 'node:os';
 import { NodeIKernelMsgListener, NodeIKernelProfileListener } from '@/core/listeners';
 import { proxiedListenerOf } from '@/common/proxy-handler';
 import { NTQQPacketApi } from './apis/packet';
+import { NativePacketHandler } from './packet/handler/client';
 export * from './wrapper';
 export * from './types';
 export * from './services';
@@ -258,6 +259,7 @@ export interface InstanceContext {
     readonly loginService: NodeIKernelLoginService;
     readonly basicInfoWrapper: QQBasicInfoWrapper;
     readonly pathWrapper: NapCatPathWrapper;
+    readonly packetHandler: NativePacketHandler;
 }
 
 export interface StableNTApiWrapper {

src/core/packet/client/baseClient.ts

@@ -1,88 +0,0 @@
-import crypto, { createHash } from 'crypto';
-import { OidbPacket, PacketHexStr } from '@/core/packet/transformer/base';
-import { LogStack } from '@/core/packet/context/clientContext';
-import { NapCoreContext } from '@/core/packet/context/napCoreContext';
-import { PacketLogger } from '@/core/packet/context/loggerContext';
-
-export interface RecvPacket {
-    type: string, // 仅recv
-    data: RecvPacketData
-}
-
-export interface RecvPacketData {
-    seq: number
-    cmd: string
-    hex_data: string
-}
-
-function randText(len: number): string {
-    let text = '';
-    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    for (let i = 0; i < len; i++) {
-        text += possible.charAt(Math.floor(Math.random() * possible.length));
-    }
-    return text;
-}
-
-
-export abstract class IPacketClient {
-    protected readonly napcore: NapCoreContext;
-    protected readonly logger: PacketLogger;
-    protected readonly cb = new Map<string, (json: RecvPacketData) => Promise<any> | any>(); // hash-type callback
-    logStack: LogStack;
-    available: boolean = false;
-
-    protected constructor(napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) {
-        this.napcore = napCore;
-        this.logger = logger;
-        this.logStack = logStack;
-    }
-
-    abstract check(): boolean;
-
-    abstract init(pid: number, recv: string, send: string): Promise<void>;
-
-    abstract sendCommandImpl(cmd: string, data: string, hash: string, timeout: number): void;
-
-    private async sendCommand(cmd: string, data: string, trace_data: string, rsp: boolean = false, timeout: number = 20000, sendcb: (json: RecvPacketData) => void = () => {
-    }): Promise<RecvPacketData> {
-        return new Promise<RecvPacketData>((resolve, reject) => {
-            if (!this.available) {
-                reject(new Error('packetBackend 当前不可用！'));
-            }
-            let hash = createHash('md5').update(trace_data).digest('hex');
-            const timeoutHandle = setTimeout(() => {
-                this.cb.delete(hash + 'send');
-                this.cb.delete(hash + 'recv');
-                reject(new Error(`sendCommand timed out after ${timeout} ms for ${cmd} with hash ${hash}`));
-            }, timeout);
-            this.cb.set(hash + 'send', async (json: RecvPacketData) => {
-                sendcb(json);
-                if (!rsp) {
-                    clearTimeout(timeoutHandle);
-                    resolve(json);
-                }
-            });
-
-            if (rsp) {
-                this.cb.set(hash + 'recv', async (json: RecvPacketData) => {
-                    clearTimeout(timeoutHandle);
-                    resolve(json);
-                });
-            }
-            this.sendCommandImpl(cmd, data, hash, timeout);
-        });
-    }
-
-    async sendPacket(cmd: string, data: PacketHexStr, rsp = false, timeout = 20000): Promise<RecvPacketData> {
-        const md5 = crypto.createHash('md5').update(data).digest('hex');
-        const trace_data = (randText(4) + md5 + data).slice(0, data.length / 2);// trace_data
-        return this.sendCommand(cmd, data, trace_data, rsp, timeout, async () => {
-            await this.napcore.sendSsoCmdReqByContend(cmd, trace_data);
-        });
-    }
-
-    async sendOidbPacket(pkt: OidbPacket, rsp = false, timeout = 20000): Promise<RecvPacketData> {
-        return this.sendPacket(pkt.cmd, pkt.data, rsp, timeout);
-    }
-}

src/core/packet/client/nativeClient.ts

@@ -1,27 +1,40 @@
-import { createHash } from 'crypto';
 import path, { dirname } from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
-import { IPacketClient } from '@/core/packet/client/baseClient';
 import { constants } from 'node:os';
 import { LogStack } from '@/core/packet/context/clientContext';
 import { NapCoreContext } from '@/core/packet/context/napCoreContext';
 import { PacketLogger } from '@/core/packet/context/loggerContext';
+import { OidbPacket, PacketBuf } from '@/core/packet/transformer/base';
+export interface RecvPacket {
+    type: string, // 仅recv
+    data: RecvPacketData
+}
+
+export interface RecvPacketData {
+    seq: number
+    cmd: string
+    data: Buffer
+}
 
 // 0 send 1 recv
 export interface NativePacketExportType {
-    InitHook?: (send: string, recv: string, callback: (type: number, uin: string, cmd: string, seq: number, hex_data: string) => void, o3_hook: boolean) => boolean;
-    SendPacket?: (cmd: string, data: string, trace_id: string) => void;
+    initHook?: (send: string, recv: string) => boolean;
 }
 
-export class NativePacketClient extends IPacketClient {
+export class NativePacketClient {
+    protected readonly napcore: NapCoreContext;
+    protected readonly logger: PacketLogger;
+    protected readonly cb = new Map<string, (json: RecvPacketData) => Promise<any> | any>(); // hash-type callback
+    logStack: LogStack;
+    available: boolean = false;
     private readonly supportedPlatforms = ['win32.x64', 'linux.x64', 'linux.arm64', 'darwin.x64', 'darwin.arm64'];
     private readonly MoeHooExport: { exports: NativePacketExportType } = { exports: {} };
-    private readonly sendEvent = new Map<number, string>(); // seq - hash
-    private readonly timeEvent = new Map<string, NodeJS.Timeout>(); // hash - timeout
 
     constructor(napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) {
-        super(napCore, logger, logStack);
+        this.napcore = napCore;
+        this.logger = logger;
+        this.logStack = logStack;
     }
 
     check(): boolean {
@@ -30,7 +43,7 @@ export class NativePacketClient extends IPacketClient {
             this.logStack.pushLogWarn(`NativePacketClient: 不支持的平台: ${platform}`);
             return false;
         }
-        const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './moehoo/MoeHoo.' + platform + '.node');
+        const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './native/napi2native/napi2native.' + platform + '.node');
         if (!fs.existsSync(moehoo_path)) {
             this.logStack.pushLogWarn(`NativePacketClient: 缺失运行时文件: ${moehoo_path}`);
             return false;
@@ -40,36 +53,55 @@ export class NativePacketClient extends IPacketClient {
 
     async init(_pid: number, recv: string, send: string): Promise<void> {
         const platform = process.platform + '.' + process.arch;
-        const isNewQQ = this.napcore.basicInfo.requireMinNTQQBuild("36580");
-        const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './moehoo/MoeHoo.' + platform + (isNewQQ ? '.new' : '') + '.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) => {
-            const hash = createHash('md5').update(Buffer.from(hex_data, 'hex')).digest('hex');
-            if (type === 0 && this.cb.get(hash + 'recv')) {
-                //此时为send 提取seq
-                this.sendEvent.set(seq, hash);
-                setTimeout(() => {
-                    this.sendEvent.delete(seq);
-                    this.timeEvent.delete(hash);
-                }, +(this.timeEvent.get(hash) ?? 20000));
-                //正式send完成 无recv v
-                //均无异常 v
-            }
-            if (type === 1 && this.sendEvent.get(seq)) {
-                const hash = this.sendEvent.get(seq);
-                const callback = this.cb.get(hash + 'recv');
-                callback?.({ seq, cmd, hex_data });
-            }
-        }, this.napcore.config.o3HookMode == 1);
-        this.available = true;
+        const isNewQQ = this.napcore.basicInfo.requireMinNTQQBuild("40824");
+        if (isNewQQ) {
+            const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './native/napi2native/napi2native.' + platform + '.node');
+            process.dlopen(this.MoeHooExport, moehoo_path, constants.dlopen.RTLD_LAZY);
+            this.MoeHooExport?.exports.initHook?.(send, recv);
+            this.available = true;
+        }
     }
 
-    sendCommandImpl(cmd: string, data: string, hash: string, timeout: number): void {
-        this.timeEvent.set(hash, setTimeout(() => {
-            this.timeEvent.delete(hash);//考虑情况为正式send都没进
-        }, timeout));
-        this.MoeHooExport.exports.SendPacket?.(cmd, data, hash);
-        this.cb.get(hash + 'send')?.({ seq: 0, cmd, hex_data: '' });
+    async sendPacket(
+        cmd: string,
+        data: PacketBuf,
+        rsp = false,
+        timeout = 5000
+    ): Promise<RecvPacketData> {
+        if (!rsp) {
+            this.napcore
+                .sendSsoCmdReqByContend(cmd, data)
+                .catch(err =>
+                    this.logger.error(
+                        `[PacketClient] sendPacket 无响应命令发送失败 cmd=${cmd} err=${err}`
+                    )
+                );
+            return { seq: 0, cmd, data: Buffer.alloc(0) };
+        }
+
+        const sendPromise = this.napcore
+            .sendSsoCmdReqByContend(cmd, data)
+            .then(ret => ({
+                seq: 0,
+                cmd,
+                data: (ret as { rspbuffer: Buffer }).rspbuffer
+            }));
+
+        const timeoutPromise = new Promise<RecvPacketData>((_, reject) => {
+            setTimeout(
+                () =>
+                    reject(
+                        new Error(
+                            `[PacketClient] sendPacket 超时 cmd=${cmd} timeout=${timeout}ms`
+                        )
+                    ),
+                timeout
+            );
+        });
+
+        return Promise.race([sendPromise, timeoutPromise]);
+    }
+    async sendOidbPacket(pkt: OidbPacket, rsp = false, timeout = 5000): Promise<RecvPacketData> {
+        return await this.sendPacket(pkt.cmd, pkt.data, rsp, timeout);
     }
 }

src/core/packet/context/clientContext.ts

@@ -1,17 +1,8 @@
-import { IPacketClient } from '@/core/packet/client/baseClient';
 import { NativePacketClient } from '@/core/packet/client/nativeClient';
 import { OidbPacket } from '@/core/packet/transformer/base';
 import { PacketLogger } from '@/core/packet/context/loggerContext';
 import { NapCoreContext } from '@/core/packet/context/napCoreContext';
 
-type clientPriorityType = {
-    [key: number]: (napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) => IPacketClient;
-}
-
-const clientPriority: clientPriorityType = {
-    10: (napCore: NapCoreContext, logger: PacketLogger, logStack: LogStack) => new NativePacketClient(napCore, logger, logStack)
-};
-
 export class LogStack {
     private stack: string[] = [];
     private readonly logger: PacketLogger;
@@ -52,7 +43,7 @@ export class PacketClientContext {
     private readonly napCore: NapCoreContext;
     private readonly logger: PacketLogger;
     private readonly logStack: LogStack;
-    private readonly _client: IPacketClient;
+    private readonly _client: NativePacketClient;
 
     constructor(napCore: NapCoreContext, logger: PacketLogger) {
         this.napCore = napCore;
@@ -75,48 +66,15 @@ export class PacketClientContext {
 
     async sendOidbPacket<T extends boolean = false>(pkt: OidbPacket, rsp?: T, timeout?: number): Promise<T extends true ? Buffer : void> {
         const raw = await this._client.sendOidbPacket(pkt, rsp, timeout);
-        return (rsp ? Buffer.from(raw.hex_data, 'hex') : undefined) as T extends true ? Buffer : void;
+        return raw.data as T extends true ? Buffer : void;
     }
 
-    private newClient(): IPacketClient {
-        const prefer = this.napCore.config.packetBackend;
-        let client: IPacketClient | null;
-        switch (prefer) {
-        case 'native':
-            this.logger.info('使用指定的 NativePacketClient 作为后端');
-            client = new NativePacketClient(this.napCore, this.logger, this.logStack);
-            break;
-        case 'auto':
-        case undefined:
-            client = this.judgeClient();
-            break;
-        default:
-            this.logger.error(`未知的PacketBackend ${prefer}，请检查配置文件！`);
-            client = null;
-        }
-        if (!client?.check()) {
-            throw new Error('[Core] [Packet] 无可用的后端，NapCat.Packet将不会加载！');
-        }
-        if (!client) {
-            throw new Error('[Core] [Packet] 后端异常，NapCat.Packet将不会加载！');
+    private newClient(): NativePacketClient {
+        this.logger.info('使用 NativePacketClient 作为后端');
+        const client = new NativePacketClient(this.napCore, this.logger, this.logStack);
+        if (!client.check()) {
+            throw new Error('[Core] [Packet] NativePacketClient 不可用，NapCat.Packet将不会加载！');
         }
         return client;
     }
-
-    private judgeClient(): IPacketClient {
-        const sortedClients = Object.entries(clientPriority)
-            .map(([priority, clientFactory]) => {
-                const client = clientFactory(this.napCore, this.logger, this.logStack);
-                const score = +priority * +client.check();
-                return { client, score };
-            })
-            .filter(({ score }) => score > 0)
-            .sort((a, b) => b.score - a.score);
-        const selectedClient = sortedClients[0]?.client;
-        if (!selectedClient) {
-            throw new Error('[Core] [Packet] 无可用的后端，NapCat.Packet将不会加载！');
-        }
-        this.logger.info(`自动选择 ${selectedClient.constructor.name} 作为后端`);
-        return selectedClient;
-    }
 }

src/core/packet/context/napCoreContext.ts

@@ -34,5 +34,5 @@ export class NapCoreContext {
         return this.core.configLoader.configData;
     }
 
-    sendSsoCmdReqByContend = (cmd: string, trace_id: string) => this.core.context.session.getMsgService().sendSsoCmdReqByContend(cmd, trace_id);
+    sendSsoCmdReqByContend = (cmd: string, data: Buffer) => this.core.context.session.getMsgService().sendSsoCmdReqByContend(cmd, data);
 }

src/core/packet/context/operationContext.ts

@@ -122,28 +122,28 @@ export class PacketOperationContext {
         return `https://${res.download.info.domain}${res.download.info.urlPath}${res.download.rKeyParam}`;
     }
 
-    async GetPttUrl(selfUid: string, node: NapProtoEncodeStructType<typeof IndexNode>,timeout: number = 20000) {
+    async GetPttUrl(selfUid: string, node: NapProtoEncodeStructType<typeof IndexNode>, timeout?: number) {
         const req = trans.DownloadPtt.build(selfUid, node);
         const resp = await this.context.client.sendOidbPacket(req, true, timeout);
         const res = trans.DownloadPtt.parse(resp);
         return `https://${res.download.info.domain}${res.download.info.urlPath}${res.download.rKeyParam}`;
     }
 
-    async GetVideoUrl(selfUid: string, node: NapProtoEncodeStructType<typeof IndexNode>, timeout: number = 20000) {
+    async GetVideoUrl(selfUid: string, node: NapProtoEncodeStructType<typeof IndexNode>, timeout?: number) {
         const req = trans.DownloadVideo.build(selfUid, node);
         const resp = await this.context.client.sendOidbPacket(req, true, timeout);
         const res = trans.DownloadVideo.parse(resp);
         return `https://${res.download.info.domain}${res.download.info.urlPath}${res.download.rKeyParam}`;
     }
 
-    async GetGroupImageUrl(groupUin: number, node: NapProtoEncodeStructType<typeof IndexNode>, timeout: number = 20000) {
+    async GetGroupImageUrl(groupUin: number, node: NapProtoEncodeStructType<typeof IndexNode>, timeout?: number) {
         const req = trans.DownloadGroupImage.build(groupUin, node);
         const resp = await this.context.client.sendOidbPacket(req, true, timeout);
         const res = trans.DownloadImage.parse(resp);
         return `https://${res.download.info.domain}${res.download.info.urlPath}${res.download.rKeyParam}`;
     }
 
-    async GetGroupPttUrl(groupUin: number, node: NapProtoEncodeStructType<typeof IndexNode>, timeout: number = 20000) {
+    async GetGroupPttUrl(groupUin: number, node: NapProtoEncodeStructType<typeof IndexNode>, timeout?: number) {
         const req = trans.DownloadGroupPtt.build(groupUin, node);
         const resp = await this.context.client.sendOidbPacket(req, true, timeout);
         const res = trans.DownloadImage.parse(resp);
@@ -243,14 +243,14 @@ export class PacketOperationContext {
         return res.rename.retCode;
     }
 
-    async GetGroupFileUrl(groupUin: number, fileUUID: string,timeout: number = 20000) {
+    async GetGroupFileUrl(groupUin: number, fileUUID: string, timeout?: number) {
         const req = trans.DownloadGroupFile.build(groupUin, fileUUID);
         const resp = await this.context.client.sendOidbPacket(req, true, timeout);
         const res = trans.DownloadGroupFile.parse(resp);
         return `https://${res.download.downloadDns}/ftn_handler/${Buffer.from(res.download.downloadUrl).toString('hex')}/?fname=`;
     }
 
-    async GetPrivateFileUrl(self_id: string, fileUUID: string, md5: string, timeout: number = 20000) {
+    async GetPrivateFileUrl(self_id: string, fileUUID: string, md5: string, timeout?: number) {
         const req = trans.DownloadPrivateFile.build(self_id, fileUUID, md5);
         const resp = await this.context.client.sendOidbPacket(req, true, timeout);
         const res = trans.DownloadPrivateFile.parse(resp);

src/core/packet/handler/client.ts

@@ -0,0 +1,214 @@
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import { constants } from 'node:os';
+import { LogWrapper } from '@/common/log';
+import offset from '@/core/external/packet.json';
+interface OffsetType {
+    [key: string]: {
+        recv: string;
+        send: string;
+    };
+}
+
+const typedOffset: OffsetType = offset;
+// 0 send 1 recv
+export interface NativePacketExportType {
+    initHook?: (send: string, recv: string, callback: (type: PacketType, uin: string, cmd: string, seq: number, hex_data: string) => void, o3_hook: boolean) => boolean;
+}
+
+export type PacketType = 0 | 1; // 0: send, 1: recv
+export type PacketCallback = (data: { type: PacketType, uin: string, cmd: string, seq: number, hex_data: string }) => void;
+
+interface ListenerEntry {
+    callback: PacketCallback;
+    once: boolean;
+}
+
+export class NativePacketHandler {
+    private readonly supportedPlatforms = ['win32.x64', 'linux.x64', 'linux.arm64', 'darwin.x64', 'darwin.arm64'];
+    private readonly MoeHooExport: { exports: NativePacketExportType } = { exports: {} };
+    protected readonly logger: LogWrapper;
+
+    // 统一的监听器存储 - key: 'all' | 'type:0' | 'type:1' | 'cmd:xxx' | 'exact:type:cmd'
+    private readonly listeners: Map<string, Set<ListenerEntry>> = new Map();
+
+
+    constructor({ logger }: { logger: LogWrapper }) {
+        this.logger = logger;
+    }
+
+    /**
+     * 添加监听器的通用方法
+     */
+    private addListener(key: string, callback: PacketCallback, once: boolean = false): () => void {
+        if (!this.listeners.has(key)) {
+            this.listeners.set(key, new Set());
+        }
+        const entry: ListenerEntry = { callback, once };
+        this.listeners.get(key)!.add(entry);
+        return () => this.removeListener(key, callback);
+    }
+
+    /**
+     * 移除监听器的通用方法
+     */
+    private removeListener(key: string, callback: PacketCallback): boolean {
+        const entries = this.listeners.get(key);
+        if (!entries) return false;
+
+        for (const entry of entries) {
+            if (entry.callback === callback) {
+                return entries.delete(entry);
+            }
+        }
+        return false;
+    }
+
+    // ===== 永久监听器 =====
+
+    /** 监听所有数据包 */
+    onAll(callback: PacketCallback): () => void {
+        return this.addListener('all', callback);
+    }
+
+    /** 监听特定类型的数据包 (0: send, 1: recv) */
+    onType(type: PacketType, callback: PacketCallback): () => void {
+        return this.addListener(`type:${type}`, callback);
+    }
+
+    /** 监听所有发送的数据包 */
+    onSend(callback: PacketCallback): () => void {
+        return this.onType(0, callback);
+    }
+
+    /** 监听所有接收的数据包 */
+    onRecv(callback: PacketCallback): () => void {
+        return this.onType(1, callback);
+    }
+
+    /** 监听特定cmd的数据包(不限type) */
+    onCmd(cmd: string, callback: PacketCallback): () => void {
+        return this.addListener(`cmd:${cmd}`, callback);
+    }
+
+    /** 监听特定type和cmd的数据包(精确匹配) */
+    onExact(type: PacketType, cmd: string, callback: PacketCallback): () => void {
+        return this.addListener(`exact:${type}:${cmd}`, callback);
+    }
+
+    // ===== 一次性监听器 =====
+
+    /** 一次性监听所有数据包 */
+    onceAll(callback: PacketCallback): () => void {
+        return this.addListener('all', callback, true);
+    }
+
+    /** 一次性监听特定类型的数据包 */
+    onceType(type: PacketType, callback: PacketCallback): () => void {
+        return this.addListener(`type:${type}`, callback, true);
+    }
+
+    /** 一次性监听所有发送的数据包 */
+    onceSend(callback: PacketCallback): () => void {
+        return this.onceType(0, callback);
+    }
+
+    /** 一次性监听所有接收的数据包 */
+    onceRecv(callback: PacketCallback): () => void {
+        return this.onceType(1, callback);
+    }
+
+    /** 一次性监听特定cmd的数据包 */
+    onceCmd(cmd: string, callback: PacketCallback): () => void {
+        return this.addListener(`cmd:${cmd}`, callback, true);
+    }
+
+    /** 一次性监听特定type和cmd的数据包 */
+    onceExact(type: PacketType, cmd: string, callback: PacketCallback): () => void {
+        return this.addListener(`exact:${type}:${cmd}`, callback, true);
+    }
+
+    // ===== 移除监听器 =====
+
+    /** 移除特定的全局监听器 */
+    off(key: string, callback: PacketCallback): boolean {
+        return this.removeListener(key, callback);
+    }
+
+    /** 移除特定key下的所有监听器 */
+    offAll(key: string): void {
+        this.listeners.delete(key);
+    }
+
+    /** 移除所有监听器 */
+    removeAllListeners(): void {
+        this.listeners.clear();
+    }
+
+    /**
+     * 触发监听器 - 按优先级触发: 精确匹配 > cmd匹配 > type匹配 > 全局
+     */
+    private emitPacket(type: PacketType, uin: string, cmd: string, seq: number, hex_data: string): void {
+        const keys = [
+            `exact:${type}:${cmd}`,  // 精确匹配
+            `cmd:${cmd}`,            // cmd匹配
+            `type:${type}`,          // type匹配
+            'all'                    // 全局
+        ];
+
+        for (const key of keys) {
+            const entries = this.listeners.get(key);
+            if (!entries) continue;
+
+            const toRemove: ListenerEntry[] = [];
+            for (const entry of entries) {
+                try {
+                    entry.callback({ type, uin, cmd, seq, hex_data });
+                    if (entry.once) {
+                        toRemove.push(entry);
+                    }
+                } catch (error) {
+                    this.logger.logError('监听器回调执行出错:', error);
+                }
+            }
+
+            // 移除一次性监听器
+            for (const entry of toRemove) {
+                entries.delete(entry);
+            }
+        }
+    }
+
+    async init(version: string): Promise<boolean> {
+        const version_arch = version + '-' + process.arch;
+        try {
+            const send = typedOffset[version_arch]?.send;
+            const recv = typedOffset[version_arch]?.recv;
+            if (!send || !recv) {
+                this.logger.logWarn(`NativePacketClient: 未找到对应版本的偏移数据: ${version_arch}`);
+                return false;
+            }
+            const platform = process.platform + '.' + process.arch;
+            if (!this.supportedPlatforms.includes(platform)) {
+                this.logger.logWarn(`NativePacketClient: 不支持的平台: ${platform}`);
+                return false;
+            }
+            const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './native/packet/MoeHoo.' + platform + '.node');
+
+            process.dlopen(this.MoeHooExport, moehoo_path, constants.dlopen.RTLD_LAZY);
+            if (!fs.existsSync(moehoo_path)) {
+                this.logger.logWarn(`NativePacketClient: 缺失运行时文件: ${moehoo_path}`);
+                return false;
+            }
+            this.MoeHooExport.exports.initHook?.(send, recv, (type: PacketType, uin: string, cmd: string, seq: number, hex_data: string) => {
+                this.emitPacket(type, uin, cmd, seq, hex_data);
+            }, true);
+            return true;
+        }
+        catch (error) {
+            this.logger.logError('NativePacketClient 初始化出错:', error);
+            return false;
+        }
+    }
+}

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

@@ -1,6 +1,6 @@
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 import { MiniAppReqParams } from '@/core/packet/entities/miniApp';
 
 class GetMiniAppAdaptShareInfo extends PacketTransformer<typeof proto.MiniAppAdaptShareInfoResp> {
@@ -41,7 +41,7 @@ class GetMiniAppAdaptShareInfo extends PacketTransformer<typeof proto.MiniAppAda
         });
         return {
             cmd: 'LightAppSvc.mini_app_share.AdaptShareInfo',
-            data: PacketHexStrBuilder(data)
+            data: PacketBufBuilder(data)
         };
     }
 

src/core/packet/transformer/base.ts

@@ -1,15 +1,15 @@
 import { NapProtoDecodeStructType } from '@napneko/nap-proto-core';
 import { PacketMsgBuilder } from '@/core/packet/message/builder';
 
-export type PacketHexStr = string & { readonly hexNya: unique symbol };
+export type PacketBuf = Buffer & { readonly hexNya: unique symbol };
 
-export const PacketHexStrBuilder = (str: Uint8Array): PacketHexStr => {
-    return Buffer.from(str).toString('hex') as PacketHexStr;
+export const PacketBufBuilder = (str: Uint8Array): PacketBuf => {
+    return Buffer.from(str) as PacketBuf;
 };
 
 export interface OidbPacket {
     cmd: string;
-    data: PacketHexStr
+    data: PacketBuf
 }
 
 export abstract class PacketTransformer<T> {

src/core/packet/transformer/highway/FetchSessionKey.ts

@@ -1,6 +1,6 @@
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 
 class FetchSessionKey extends PacketTransformer<typeof proto.HttpConn0x6ff_501Response> {
     constructor() {
@@ -25,7 +25,7 @@ class FetchSessionKey extends PacketTransformer<typeof proto.HttpConn0x6ff_501Re
         });
         return {
             cmd: 'HttpConn.0x6ff_501',
-            data: PacketHexStrBuilder(req)
+            data: PacketBufBuilder(req)
         };
     }
 

src/core/packet/transformer/message/DownloadForwardMsg.ts

@@ -1,6 +1,6 @@
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 
 class DownloadForwardMsg extends PacketTransformer<typeof proto.RecvLongMsgResp> {
     constructor() {
@@ -25,7 +25,7 @@ class DownloadForwardMsg extends PacketTransformer<typeof proto.RecvLongMsgResp>
         });
         return {
             cmd: 'trpc.group.long_msg_interface.MsgService.SsoRecvLongMsg',
-            data: PacketHexStrBuilder(req)
+            data: PacketBufBuilder(req)
         };
     }
 

src/core/packet/transformer/message/FetchC2CMessage.ts

@@ -1,6 +1,6 @@
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 
 class FetchC2CMessage extends PacketTransformer<typeof proto.SsoGetC2cMsgResponse> {
     constructor() {
@@ -15,7 +15,7 @@ class FetchC2CMessage extends PacketTransformer<typeof proto.SsoGetC2cMsgRespons
         });
         return {
             cmd: 'trpc.msg.register_proxy.RegisterProxy.SsoGetC2cMsg',
-            data: PacketHexStrBuilder(req)
+            data: PacketBufBuilder(req)
         };
     }
 

src/core/packet/transformer/message/FetchGroupMessage.ts

@@ -1,6 +1,6 @@
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 
 class FetchGroupMessage extends PacketTransformer<typeof proto.SsoGetGroupMsgResponse> {
     constructor() {
@@ -18,7 +18,7 @@ class FetchGroupMessage extends PacketTransformer<typeof proto.SsoGetGroupMsgRes
         });
         return {
             cmd: 'trpc.msg.register_proxy.RegisterProxy.SsoGetGroupMsg',
-            data: PacketHexStrBuilder(req)
+            data: PacketBufBuilder(req)
         };
     }
 

src/core/packet/transformer/message/UploadForwardMsg.ts

@@ -1,7 +1,7 @@
 import zlib from 'node:zlib';
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 import { PacketMsg } from '@/core/packet/message/message';
 
 class UploadForwardMsg extends PacketTransformer<typeof proto.SendLongMsgResp> {
@@ -39,7 +39,7 @@ class UploadForwardMsg extends PacketTransformer<typeof proto.SendLongMsgResp> {
         );
         return {
             cmd: 'trpc.group.long_msg_interface.MsgService.SsoSendLongMsg',
-            data: PacketHexStrBuilder(req)
+            data: PacketBufBuilder(req)
         };
     }
 

src/core/packet/transformer/oidb/oidbBase.ts

@@ -1,6 +1,6 @@
 import * as proto from '@/core/packet/transformer/proto';
 import { NapProtoMsg } from '@napneko/nap-proto-core';
-import { OidbPacket, PacketHexStrBuilder, PacketTransformer } from '@/core/packet/transformer/base';
+import { OidbPacket, PacketBufBuilder, PacketTransformer } from '@/core/packet/transformer/base';
 
 class OidbBase extends PacketTransformer<typeof proto.OidbSvcTrpcTcpBase> {
     constructor() {
@@ -16,7 +16,7 @@ class OidbBase extends PacketTransformer<typeof proto.OidbSvcTrpcTcpBase> {
         });
         return {
             cmd: `OidbSvcTrpcTcp.0x${cmd.toString(16).toUpperCase()}_${subCmd}`,
-            data: PacketHexStrBuilder(data),
+            data: PacketBufBuilder(data),
         };
     }
 

src/core/services/NodeIKernelMsgService.ts

@@ -585,7 +585,7 @@ export interface NodeIKernelMsgService {
 
     prepareTempChat(args: unknown): unknown;
 
-    sendSsoCmdReqByContend(cmd: string, param: string): Promise<unknown>;
+    sendSsoCmdReqByContend(cmd: string, param: unknown): Promise<unknown>;
 
     getTempChatInfo(ChatType: number, Uid: string): Promise<TmpChatInfoApi>;
 

src/framework/napcat.ts

@@ -9,8 +9,8 @@ import { NodeIKernelLoginService } from '@/core/services';
 import { NodeIQQNTWrapperSession, WrapperNodeApi } from '@/core/wrapper';
 import { InitWebUi, WebUiConfig, webUiRuntimePort } from '@/webui';
 import { NapCatOneBot11Adapter } from '@/onebot';
-import { downloadFFmpegIfNotExists } from '@/common/download-ffmpeg';
 import { FFmpegService } from '@/common/ffmpeg';
+import { NativePacketHandler } from '@/core/packet/handler/client';
 
 //Framework ES入口文件
 export async function getWebUiUrl() {
@@ -38,15 +38,15 @@ export async function NCoreInitFramework(
     const logger = new LogWrapper(pathWrapper.logsPath);
     const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
     const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVersion());
-    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 nativePacketHandler = new NativePacketHandler({ logger }); // 初始化 NativePacketHandler 用于后续使用
+    nativePacketHandler.onAll((packet) => {
+        console.log('[Packet]', packet.uin, packet.cmd, packet.hex_data);
+    });
+    await nativePacketHandler.init(basicInfoWrapper.getFullQQVersion());
+    // 在 init 之后注册监听器
+
+    // 初始化 FFmpeg 服务
+    await FFmpegService.init(pathWrapper.binaryPath, logger);
     //直到登录成功后，执行下一步
     // const selfInfo = {
     //     uid: 'u_FUSS0_x06S_9Tf4na_WpUg',
@@ -72,7 +72,7 @@ export async function NCoreInitFramework(
     // 过早进入会导致addKernelMsgListener等Listener添加失败
     // await sleep(2500);
     // 初始化 NapCatFramework
-    const loaderObject = new NapCatFramework(wrapper, session, logger, loginService, selfInfo, basicInfoWrapper, pathWrapper);
+    const loaderObject = new NapCatFramework(wrapper, session, logger, loginService, selfInfo, basicInfoWrapper, pathWrapper, nativePacketHandler);
     await loaderObject.core.initCore();
 
     //启动WebUi
@@ -93,8 +93,10 @@ export class NapCatFramework {
         selfInfo: SelfInfo,
         basicInfoWrapper: QQBasicInfoWrapper,
         pathWrapper: NapCatPathWrapper,
+        packetHandler: NativePacketHandler,
     ) {
         this.context = {
+            packetHandler,
             workingEnv: NapCatCoreWorkingEnv.Framework,
             wrapper,
             session,

src/onebot/action/OneBotAction.ts

@@ -4,9 +4,10 @@ import { NapCatCore } from '@/core';
 import { NapCatOneBot11Adapter, OB11Return } from '@/onebot';
 import { NetworkAdapterConfig } from '../config/config';
 import { TSchema } from '@sinclair/typebox';
+import { StreamPacket, StreamPacketBasic, StreamStatus } from './stream/StreamBasic';
 
 export class OB11Response {
-    private static createResponse<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null): OB11Return<T> {
+    private static createResponse<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null, useStream: boolean = false): OB11Return<T> {
         return {
             status,
             retcode,
@@ -14,28 +15,32 @@ export class OB11Response {
             message,
             wording: message,
             echo,
+            stream: useStream ? 'stream-action' : 'normal-action'
         };
     }
 
-    static res<T>(data: T, status: string, retcode: number, message: string = ''): OB11Return<T> {
-        return this.createResponse(data, status, retcode, message);
+    static res<T>(data: T, status: string, retcode: number, message: string = '', echo: unknown = null, useStream: boolean = false): OB11Return<T> {
+        return this.createResponse(data, status, retcode, message, echo, useStream);
     }
 
-    static ok<T>(data: T, echo: unknown = null): OB11Return<T> {
-        return this.createResponse(data, 'ok', 0, '', echo);
+    static ok<T>(data: T, echo: unknown = null, useStream: boolean = false): OB11Return<T> {
+        return this.createResponse(data, 'ok', 0, '', echo, useStream);
     }
 
-    static error(err: string, retcode: number, echo: unknown = null): OB11Return<null> {
-        return this.createResponse(null, 'failed', retcode, err, echo);
+    static error(err: string, retcode: number, echo: unknown = null, useStream: boolean = false): OB11Return<null | StreamPacketBasic> {
+        return this.createResponse(useStream ? { type: StreamStatus.Error, data_type: 'error' } : null, 'failed', retcode, err, echo, useStream);
     }
 }
-
+export abstract class OneBotRequestToolkit {
+    abstract send<T>(packet: StreamPacket<T>): Promise<void>;
+}
 export abstract class OneBotAction<PayloadType, ReturnDataType> {
     actionName: typeof ActionName[keyof typeof ActionName] = ActionName.Unknown;
     core: NapCatCore;
     private validate?: ValidateFunction<unknown> = undefined;
     payloadSchema?: TSchema = undefined;
     obContext: NapCatOneBot11Adapter;
+    useStream: boolean = false;
 
     constructor(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
         this.obContext = obContext;
@@ -57,33 +62,33 @@ export abstract class OneBotAction<PayloadType, ReturnDataType> {
         return { valid: true };
     }
 
-    public async handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig): Promise<OB11Return<ReturnDataType | null>> {
+    public async handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig, req: OneBotRequestToolkit = { send: async () => { } }, echo?: string): Promise<OB11Return<ReturnDataType | StreamPacketBasic | null>> {
         const result = await this.check(payload);
         if (!result.valid) {
             return OB11Response.error(result.message, 400);
         }
         try {
-            const resData = await this._handle(payload, adaptername, config);
-            return OB11Response.ok(resData);
+            const resData = await this._handle(payload, adaptername, config, req);
+            return OB11Response.ok(resData, echo, this.useStream);
         } catch (e: unknown) {
             this.core.context.logger.logError('发生错误', e);
-            return OB11Response.error((e as Error).message.toString() || (e as Error)?.stack?.toString() || '未知错误，可能操作超时', 200);
+            return OB11Response.error((e as Error).message.toString() || (e as Error)?.stack?.toString() || '未知错误，可能操作超时', 200, echo, this.useStream);
         }
     }
 
-    public async websocketHandle(payload: PayloadType, echo: unknown, adaptername: string, config: NetworkAdapterConfig): Promise<OB11Return<ReturnDataType | null>> {
+    public async websocketHandle(payload: PayloadType, echo: unknown, adaptername: string, config: NetworkAdapterConfig, req: OneBotRequestToolkit = { send: async () => { } }): Promise<OB11Return<ReturnDataType | StreamPacketBasic | null>> {
         const result = await this.check(payload);
         if (!result.valid) {
-            return OB11Response.error(result.message, 1400, echo);
+            return OB11Response.error(result.message, 1400, echo, this.useStream);
         }
         try {
-            const resData = await this._handle(payload, adaptername, config);
-            return OB11Response.ok(resData, echo);
+            const resData = await this._handle(payload, adaptername, config, req);
+            return OB11Response.ok(resData, echo, this.useStream);
         } catch (e: unknown) {
             this.core.context.logger.logError('发生错误', e);
-            return OB11Response.error(((e as Error).message.toString() || (e as Error).stack?.toString()) ?? 'Error', 1200, echo);
+            return OB11Response.error(((e as Error).message.toString() || (e as Error).stack?.toString()) ?? 'Error', 1200, echo, this.useStream);
         }
     }
 
-    abstract _handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig): Promise<ReturnDataType>;
+    abstract _handle(payload: PayloadType, adaptername: string, config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<ReturnDataType>;
 }

src/onebot/action/extends/GetUnidirectionalFriendList.ts

@@ -1,4 +1,4 @@
-import { PacketHexStr } from '@/core/packet/transformer/base';
+import { PacketBuf } from '@/core/packet/transformer/base';
 import { OneBotAction } from '@/onebot/action/OneBotAction';
 import { ActionName } from '@/onebot/action/router';
 import { ProtoBuf, ProtoBufBase, PBUint32, PBString } from 'napcat.protobuf';
@@ -39,8 +39,8 @@ export class GetUnidirectionalFriendList extends OneBotAction<void, Friend[]> {
             bytes_cookies: ""
         };
         const packed_data = await this.pack_data(JSON.stringify(req_json));
-        const data = Buffer.from(packed_data).toString('hex');
-        const rsq = { cmd: 'MQUpdateSvc_com_qq_ti.web.OidbSvc.0xe17_0', data: data as PacketHexStr };
+        const data = Buffer.from(packed_data);
+        const rsq = { cmd: 'MQUpdateSvc_com_qq_ti.web.OidbSvc.0xe17_0', data: data as PacketBuf };
         const rsp_data = await this.core.apis.PacketApi.pkt.operation.sendPacket(rsq, true);
         const block_json = ProtoBuf(class extends ProtoBufBase { data = PBString(4); }).decode(rsp_data);
         const block_list: Block[] = JSON.parse(block_json.data).rpt_block_list;

src/onebot/action/extends/SendPacket.ts

@@ -1,4 +1,4 @@
-import { PacketHexStr } from '@/core/packet/transformer/base';
+import { PacketBuf } from '@/core/packet/transformer/base';
 import { GetPacketStatusDepends } from '@/onebot/action/packet/GetPacketStatus';
 import { ActionName } from '@/onebot/action/router';
 import { Static, Type } from '@sinclair/typebox';
@@ -16,7 +16,7 @@ export class SendPacket extends GetPacketStatusDepends<Payload, string | undefin
     override actionName = ActionName.SendPacket;
     async _handle(payload: Payload) {
         const rsp = typeof payload.rsp === 'boolean' ? payload.rsp : payload.rsp === 'true';
-        const data = await this.core.apis.PacketApi.pkt.operation.sendPacket({ cmd: payload.cmd, data: payload.data as PacketHexStr }, rsp);
+        const data = await this.core.apis.PacketApi.pkt.operation.sendPacket({ cmd: payload.cmd, data: Buffer.from(payload.data, 'hex') as PacketBuf }, rsp);
         return typeof data === 'object' ? data.toString('hex') : undefined;
     }
 }

src/onebot/action/file/GetFile.ts

@@ -41,12 +41,12 @@ export class GetFileBase extends OneBotAction<GetFilePayload, GetFileResponse> {
             let url = '';
             if (mixElement?.picElement && rawMessage) {
                 const tempData =
-                    await this.obContext.apis.MsgApi.rawToOb11Converters.picElement?.(mixElement?.picElement, rawMessage, mixElement, { parseMultMsg: false }) as OB11MessageImage | undefined;
+                    await this.obContext.apis.MsgApi.rawToOb11Converters.picElement?.(mixElement?.picElement, rawMessage, mixElement, { parseMultMsg: false, disableGetUrl: false, quick_reply: true }) as OB11MessageImage | undefined;
                 url = tempData?.data.url ?? '';
             }
             if (mixElement?.videoElement && rawMessage) {
                 const tempData =
-                    await this.obContext.apis.MsgApi.rawToOb11Converters.videoElement?.(mixElement?.videoElement, rawMessage, mixElement, { parseMultMsg: false }) as OB11MessageVideo | undefined;
+                    await this.obContext.apis.MsgApi.rawToOb11Converters.videoElement?.(mixElement?.videoElement, rawMessage, mixElement, { parseMultMsg: false, disableGetUrl: false, quick_reply: true }) as OB11MessageVideo | undefined;
                 url = tempData?.data.url ?? '';
             }
             const res: GetFileResponse = {

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

@@ -1,6 +1,6 @@
 import { OneBotAction } from '@/onebot/action/OneBotAction';
 import { ActionName } from '@/onebot/action/router';
-import { ChatType, Peer } from '@/core/types';
+import { ChatType, Peer, ElementType } from '@/core/types';
 import fs from 'fs';
 import { uriToLocalFile } from '@/common/file';
 import { SendMessageContext } from '@/onebot/api';
@@ -16,11 +16,15 @@ const SchemaData = Type.Object({
 
 type Payload = Static<typeof SchemaData>;
 
-export default class GoCQHTTPUploadGroupFile extends OneBotAction<Payload, null> {
+interface UploadGroupFileResponse {
+    file_id: string | null;
+}
+
+export default class GoCQHTTPUploadGroupFile extends OneBotAction<Payload, UploadGroupFileResponse> {
     override actionName = ActionName.GoCQHTTP_UploadGroupFile;
     override payloadSchema = SchemaData;
 
-    async _handle(payload: Payload): Promise<null> {
+    async _handle(payload: Payload): Promise<UploadGroupFileResponse> {
         let file = payload.file;
         if (fs.existsSync(file)) {
             file = `file://${file}`;
@@ -39,7 +43,11 @@ export default class GoCQHTTPUploadGroupFile extends OneBotAction<Payload, null>
         };
         const sendFileEle = await this.core.apis.FileApi.createValidSendFileElement(msgContext, downloadResult.path, payload.name, payload.folder ?? payload.folder_id);
         msgContext.deleteAfterSentFiles.push(downloadResult.path);
-        await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(peer, [sendFileEle], msgContext.deleteAfterSentFiles);
-        return null;
+        const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(peer, [sendFileEle], msgContext.deleteAfterSentFiles);
+        
+        const fileElement = returnMsg.elements.find(ele => ele.elementType === ElementType.FILE);
+        return {
+            file_id: fileElement?.fileElement?.fileUuid || null
+        };
     }
 }

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

@@ -1,6 +1,6 @@
 import { OneBotAction } from '@/onebot/action/OneBotAction';
 import { ActionName } from '@/onebot/action/router';
-import { ChatType, Peer, SendFileElement } from '@/core/types';
+import { ChatType, Peer, SendFileElement, ElementType } from '@/core/types';
 import fs from 'fs';
 import { uriToLocalFile } from '@/common/file';
 import { SendMessageContext } from '@/onebot/api';
@@ -15,7 +15,11 @@ const SchemaData = Type.Object({
 
 type Payload = Static<typeof SchemaData>;
 
-export default class GoCQHTTPUploadPrivateFile extends OneBotAction<Payload, null> {
+interface UploadPrivateFileResponse {
+    file_id: string | null;
+}
+
+export default class GoCQHTTPUploadPrivateFile extends OneBotAction<Payload, UploadPrivateFileResponse> {
     override actionName = ActionName.GOCQHTTP_UploadPrivateFile;
     override payloadSchema = SchemaData;
 
@@ -31,7 +35,7 @@ export default class GoCQHTTPUploadPrivateFile extends OneBotAction<Payload, nul
         throw new Error('缺少参数 user_id');
     }
 
-    async _handle(payload: Payload): Promise<null> {
+    async _handle(payload: Payload): Promise<UploadPrivateFileResponse> {
         let file = payload.file;
         if (fs.existsSync(file)) {
             file = `file://${file}`;
@@ -49,7 +53,11 @@ export default class GoCQHTTPUploadPrivateFile extends OneBotAction<Payload, nul
         };
         const sendFileEle: SendFileElement = await this.core.apis.FileApi.createValidSendFileElement(msgContext, downloadResult.path, payload.name);
         msgContext.deleteAfterSentFiles.push(downloadResult.path);
-        await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(await this.getPeer(payload), [sendFileEle], msgContext.deleteAfterSentFiles);
-        return null;
+        const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(await this.getPeer(payload), [sendFileEle], msgContext.deleteAfterSentFiles);
+        
+        const fileElement = returnMsg.elements.find(ele => ele.elementType === ElementType.FILE);
+        return {
+            file_id: fileElement?.fileElement?.fileUuid || null
+        };
     }
 }

src/onebot/action/group/DelEssenceMsg.ts

@@ -4,7 +4,10 @@ import { MessageUnique } from '@/common/message-unique';
 import { Static, Type } from '@sinclair/typebox';
 
 const SchemaData = Type.Object({
-    message_id: Type.Union([Type.Number(), Type.String()]),
+    message_id: Type.Optional(Type.Union([Type.Number(), Type.String()])),
+    msg_seq: Type.Optional(Type.String()),
+    msg_random: Type.Optional(Type.String()),
+    group_id: Type.Optional(Type.String()),
 });
 
 type Payload = Static<typeof SchemaData>;
@@ -13,6 +16,20 @@ export default class DelEssenceMsg extends OneBotAction<Payload, unknown> {
     override payloadSchema = SchemaData;
 
     async _handle(payload: Payload): Promise<unknown> {
+        // 如果直接提供了 msg_seq, msg_random, group_id,优先使用
+        if (payload.msg_seq && payload.msg_random && payload.group_id) {
+            return await this.core.apis.GroupApi.removeGroupEssenceBySeq(
+                payload.group_id,
+                payload.msg_random,
+                payload.msg_seq,
+            );
+        }
+
+        // 如果没有 message_id,则必须提供 msg_seq, msg_random, group_id
+        if (!payload.message_id) {
+            throw new Error('必须提供 message_id 或者同时提供 msg_seq, msg_random, group_id');
+        }
+
         const msg = MessageUnique.getMsgIdAndPeerByShortId(+payload.message_id);
         if (!msg) {
             const data = this.core.apis.GroupApi.essenceLRU.getValue(+payload.message_id);

src/onebot/action/group/GetGroupInfo.ts

@@ -18,6 +18,9 @@ class GetGroupInfo extends OneBotAction<Payload, OB11Group> {
         const group = (await this.core.apis.GroupApi.getGroups()).find(e => e.groupCode == payload.group_id.toString());
         if (!group) {
             const data = await this.core.apis.GroupApi.fetchGroupDetail(payload.group_id.toString());
+            if (data.ownerUid && data.ownerUin === '0') {
+                data.ownerUin = await this.core.apis.UserApi.getUinByUidV2(data.ownerUid);
+            }
             return {
                 ...data,
                 group_all_shut: data.shutUpAllTimestamp > 0 ? -1 : 0,

src/onebot/action/index.ts

@@ -130,10 +130,22 @@ import { DoGroupAlbumComment } from './extends/DoGroupAlbumComment';
 import { GetGroupAlbumMediaList } from './extends/GetGroupAlbumMediaList';
 import { SetGroupAlbumMediaLike } from './extends/SetGroupAlbumMediaLike';
 import { DelGroupAlbumMedia } from './extends/DelGroupAlbumMedia';
+import { CleanStreamTempFile } from './stream/CleanStreamTempFile';
+import { DownloadFileStream } from './stream/DownloadFileStream';
+import { DownloadFileRecordStream } from './stream/DownloadFileRecordStream';
+import { DownloadFileImageStream } from './stream/DownloadFileImageStream';
+import { TestDownloadStream } from './stream/TestStreamDownload';
+import { UploadFileStream } from './stream/UploadFileStream';
 
 export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCore) {
 
     const actionHandlers = [
+        new CleanStreamTempFile(obContext, core),
+        new DownloadFileStream(obContext, core),
+        new DownloadFileRecordStream(obContext, core),
+        new DownloadFileImageStream(obContext, core),
+        new TestDownloadStream(obContext, core),
+        new UploadFileStream(obContext, core),
         new DelGroupAlbumMedia(obContext, core),
         new SetGroupAlbumMediaLike(obContext, core),
         new DoGroupAlbumComment(obContext, core),

src/onebot/action/router.ts

@@ -10,6 +10,16 @@ export interface InvalidCheckResult {
 }
 
 export const ActionName = {
+    // 所有 Normal Stream Api 表示并未流传输 表示与流传输有关
+    CleanStreamTempFile: 'clean_stream_temp_file',
+
+    // 所有 Upload/Download Stream Api 应当 _stream 结尾
+     TestDownloadStream: 'test_download_stream',
+    UploadFileStream: 'upload_file_stream',
+    DownloadFileStream: 'download_file_stream',
+    DownloadFileRecordStream: 'download_file_record_stream',
+    DownloadFileImageStream: 'download_file_image_stream',
+
     DelGroupAlbumMedia: 'del_group_album_media',
     SetGroupAlbumMediaLike: 'set_group_album_media_like',
     DoGroupAlbumComment: 'do_group_album_comment',

src/onebot/action/stream/BaseDownloadStream.ts

@@ -0,0 +1,99 @@
+import { OneBotAction, OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { FileNapCatOneBotUUID } from '@/common/file-uuid';
+
+export interface ResolvedFileInfo {
+    downloadPath: string;
+    fileName: string;
+    fileSize: number;
+}
+
+export interface DownloadResult {
+    // 文件信息
+    file_name?: string;
+    file_size?: number;
+    chunk_size?: number;
+
+    // 分片数据
+    index?: number;
+    data?: string;
+    size?: number;
+    progress?: number;
+    base64_size?: number;
+
+    // 完成信息
+    total_chunks?: number;
+    total_bytes?: number;
+    message?: string;
+    data_type?: 'file_info' | 'file_chunk' | 'file_complete';
+
+    // 可选扩展字段
+    width?: number;
+    height?: number;
+    out_format?: string;
+}
+
+export abstract class BaseDownloadStream<PayloadType, ResultType> extends OneBotAction<PayloadType, StreamPacket<ResultType>> {
+    protected async resolveDownload(file?: string): Promise<ResolvedFileInfo> {
+        const target = file || '';
+        let downloadPath = '';
+        let fileName = '';
+        let fileSize = 0;
+
+        const contextMsgFile = FileNapCatOneBotUUID.decode(target);
+        if (contextMsgFile && contextMsgFile.msgId && contextMsgFile.elementId) {
+            const { peer, msgId, elementId } = contextMsgFile;
+            downloadPath = await this.core.apis.FileApi.downloadMedia(msgId, peer.chatType, peer.peerUid, elementId, '', '');
+            const rawMessage = (await this.core.apis.MsgApi.getMsgsByMsgId(peer, [msgId]))?.msgList
+                .find(msg => msg.msgId === msgId);
+            const mixElement = rawMessage?.elements.find(e => e.elementId === elementId);
+            const mixElementInner = mixElement?.videoElement ?? mixElement?.fileElement ?? mixElement?.pttElement ?? mixElement?.picElement;
+            if (!mixElementInner) throw new Error('element not found');
+            fileSize = parseInt(mixElementInner.fileSize?.toString() ?? '0');
+            fileName = mixElementInner.fileName ?? '';
+            return { downloadPath, fileName, fileSize };
+        }
+
+        const contextModelIdFile = FileNapCatOneBotUUID.decodeModelId(target);
+        if (contextModelIdFile && contextModelIdFile.modelId) {
+            const { peer, modelId } = contextModelIdFile;
+            downloadPath = await this.core.apis.FileApi.downloadFileForModelId(peer, modelId, '');
+            return { downloadPath, fileName, fileSize };
+        }
+
+        const searchResult = (await this.core.apis.FileApi.searchForFile([target]));
+        if (searchResult) {
+            downloadPath = await this.core.apis.FileApi.downloadFileById(searchResult.id, parseInt(searchResult.fileSize));
+            fileSize = parseInt(searchResult.fileSize);
+            fileName = searchResult.fileName;
+            return { downloadPath, fileName, fileSize };
+        }
+
+        throw new Error('file not found');
+    }
+
+    protected async streamFileChunks(req: OneBotRequestToolkit, streamPath: string, chunkSize: number, chunkDataType: string): Promise<{ totalChunks: number; totalBytes: number }>
+    {
+        const stats = await fs.promises.stat(streamPath);
+        const totalSize = stats.size;
+        const readStream = fs.createReadStream(streamPath, { highWaterMark: chunkSize });
+        let chunkIndex = 0;
+        let bytesRead = 0;
+        for await (const chunk of readStream) {
+            const base64Chunk = (chunk as Buffer).toString('base64');
+            bytesRead += (chunk as Buffer).length;
+            await req.send({
+                type: StreamStatus.Stream,
+                data_type: chunkDataType,
+                index: chunkIndex,
+                data: base64Chunk,
+                size: (chunk as Buffer).length,
+                progress: Math.round((bytesRead / totalSize) * 100),
+                base64_size: base64Chunk.length
+            } as unknown as StreamPacket<any>);
+            chunkIndex++;
+        }
+        return { totalChunks: chunkIndex, totalBytes: bytesRead };
+    }
+}

src/onebot/action/stream/CleanStreamTempFile.ts

@@ -0,0 +1,33 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction } from '@/onebot/action/OneBotAction';
+import { join } from 'node:path';
+import { readdir, unlink } from 'node:fs/promises';
+
+export class CleanStreamTempFile extends OneBotAction<void, void> {
+    override actionName = ActionName.CleanStreamTempFile;
+
+    async _handle(_payload: void): Promise<void> {
+        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);
+        } catch (err: unknown) {
+            this.core.context.logger.log(`清理流临时文件失败: ${(err as Error).message}`);
+        }
+    }
+}

src/onebot/action/stream/DownloadFileImageStream.ts

@@ -0,0 +1,60 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { imageSizeFallBack } from '@/image-size';
+import { BaseDownloadStream, DownloadResult } from './BaseDownloadStream';
+
+const SchemaData = Type.Object({
+    file: Type.Optional(Type.String()),
+    file_id: Type.Optional(Type.String()),
+    chunk_size: Type.Optional(Type.Number({ default: 64 * 1024 })) // 默认64KB分块
+});
+
+type Payload = Static<typeof SchemaData>;
+
+export class DownloadFileImageStream extends BaseDownloadStream<Payload, DownloadResult> {
+    override actionName = ActionName.DownloadFileImageStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    async _handle(payload: Payload, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<StreamPacket<DownloadResult>> {
+        try {
+            payload.file ||= payload.file_id || '';
+            const chunkSize = payload.chunk_size || 64 * 1024;
+
+            const { downloadPath, fileName, fileSize } = await this.resolveDownload(payload.file);
+
+            const stats = await fs.promises.stat(downloadPath);
+            const totalSize = fileSize || stats.size;
+            const { width, height } = await imageSizeFallBack(downloadPath);
+
+            // 发送文件信息（与 DownloadFileStream 对齐，但包含宽高）
+            await req.send({
+                type: StreamStatus.Stream,
+                data_type: 'file_info',
+                file_name: fileName,
+                file_size: totalSize,
+                chunk_size: chunkSize,
+                width,
+                height
+            });
+
+            const { totalChunks, totalBytes } = await this.streamFileChunks(req, downloadPath, chunkSize, 'file_chunk');
+
+            // 返回完成状态（与 DownloadFileStream 对齐）
+            return {
+                type: StreamStatus.Response,
+                data_type: 'file_complete',
+                total_chunks: totalChunks,
+                total_bytes: totalBytes,
+                message: 'Download completed'
+            };
+
+        } catch (error) {
+            throw new Error(`Download failed: ${(error as Error).message}`);
+        }
+    }
+}

src/onebot/action/stream/DownloadFileRecordStream.ts

@@ -0,0 +1,96 @@
+
+import { ActionName } from '@/onebot/action/router';
+import { OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { decode } from 'silk-wasm';
+import { FFmpegService } from '@/common/ffmpeg';
+import { BaseDownloadStream } from './BaseDownloadStream';
+
+const out_format = ['mp3', 'amr', 'wma', 'm4a', 'spx', 'ogg', 'wav', 'flac'];
+
+const SchemaData = Type.Object({
+	file: Type.Optional(Type.String()),
+	file_id: Type.Optional(Type.String()),
+	chunk_size: Type.Optional(Type.Number({ default: 64 * 1024 })), // 默认64KB分块
+	out_format: Type.Optional(Type.String())
+});
+
+type Payload = Static<typeof SchemaData>;
+
+import { DownloadResult } from './BaseDownloadStream';
+
+export class DownloadFileRecordStream extends BaseDownloadStream<Payload, DownloadResult> {
+	override actionName = ActionName.DownloadFileRecordStream;
+	override payloadSchema = SchemaData;
+	override useStream = true;
+
+	async _handle(payload: Payload, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<StreamPacket<DownloadResult>> {
+		try {
+			payload.file ||= payload.file_id || '';
+			const chunkSize = payload.chunk_size || 64 * 1024;
+
+			const { downloadPath, fileName, fileSize } = await this.resolveDownload(payload.file);
+
+			// 处理输出格式转换
+			let streamPath = downloadPath;
+			if (payload.out_format && typeof payload.out_format === 'string') {
+				if (!out_format.includes(payload.out_format)) {
+					throw new Error('转换失败 out_format 字段可能格式不正确');
+				}
+
+				const pcmFile = `${downloadPath}.pcm`;
+				const outputFile = `${downloadPath}.${payload.out_format}`;
+
+				try {
+					// 如果已存在目标文件则跳过转换
+					await fs.promises.access(outputFile);
+					streamPath = outputFile;
+				} catch {
+					// 尝试解码 silk 到 pcm 再用 ffmpeg 转换
+					await this.decodeFile(downloadPath, pcmFile);
+					await FFmpegService.convertFile(pcmFile, outputFile, payload.out_format);
+					streamPath = outputFile;
+				}
+			}
+
+			const stats = await fs.promises.stat(streamPath);
+			const totalSize = fileSize || stats.size;
+
+			await req.send({
+				type: StreamStatus.Stream,
+				data_type: 'file_info',
+				file_name: fileName,
+				file_size: totalSize,
+				chunk_size: chunkSize,
+				out_format: payload.out_format
+			});
+
+			const { totalChunks, totalBytes } = await this.streamFileChunks(req, streamPath, chunkSize, 'file_chunk');
+
+			return {
+				type: StreamStatus.Response,
+				data_type: 'file_complete',
+				total_chunks: totalChunks,
+				total_bytes: totalBytes,
+				message: 'Download completed'
+			};
+
+		} catch (error) {
+			throw new Error(`Download failed: ${(error as Error).message}`);
+		}
+	}
+
+	private async decodeFile(inputFile: string, outputFile: string): Promise<void> {
+		try {
+			const inputData = await fs.promises.readFile(inputFile);
+			const decodedData = await decode(inputData, 24000);
+			await fs.promises.writeFile(outputFile, Buffer.from(decodedData.data));
+		} catch (error) {
+			console.error('Error decoding file:', error);
+			throw error;
+		}
+	}
+}

src/onebot/action/stream/DownloadFileStream.ts

@@ -0,0 +1,53 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { BaseDownloadStream, DownloadResult } from './BaseDownloadStream';
+const SchemaData = Type.Object({
+    file: Type.Optional(Type.String()),
+    file_id: Type.Optional(Type.String()),
+    chunk_size: Type.Optional(Type.Number({ default: 64 * 1024 })) // 默认64KB分块
+});
+
+type Payload = Static<typeof SchemaData>;
+
+export class DownloadFileStream extends BaseDownloadStream<Payload, DownloadResult> {
+    override actionName = ActionName.DownloadFileStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    async _handle(payload: Payload, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<StreamPacket<DownloadResult>> {
+        try {
+            payload.file ||= payload.file_id || '';
+            const chunkSize = payload.chunk_size || 64 * 1024;
+
+            const { downloadPath, fileName, fileSize } = await this.resolveDownload(payload.file);
+
+            const stats = await fs.promises.stat(downloadPath);
+            const totalSize = fileSize || stats.size;
+
+            await req.send({
+                type: StreamStatus.Stream,
+                data_type: 'file_info',
+                file_name: fileName,
+                file_size: totalSize,
+                chunk_size: chunkSize
+            });
+
+            const { totalChunks, totalBytes } = await this.streamFileChunks(req, downloadPath, chunkSize, 'file_chunk');
+
+            return {
+                type: StreamStatus.Response,
+                data_type: 'file_complete',
+                total_chunks: totalChunks,
+                total_bytes: totalBytes,
+                message: 'Download completed'
+            };
+
+        } catch (error) {
+            throw new Error(`Download failed: ${(error as Error).message}`);
+        }
+    }
+}

src/onebot/action/stream/Readme.txt

@@ -0,0 +1,3 @@
+# Stream-Api
+
+## 流式接口

src/onebot/action/stream/StreamBasic.ts

@@ -0,0 +1,16 @@
+import { OneBotAction, OneBotRequestToolkit } from "../OneBotAction";
+import { NetworkAdapterConfig } from "@/onebot/config/config";
+export type StreamPacketBasic =   {
+    type: StreamStatus;
+    data_type?: string;
+};
+export type StreamPacket<T> = T & StreamPacketBasic;
+export enum StreamStatus {
+    Stream = 'stream', // 分片流数据包
+    Response = 'response', // 流最终响应
+    Reset = 'reset', // 重置流
+    Error = 'error' // 流错误
+}
+export abstract class BasicStream<T, R> extends OneBotAction<T, StreamPacket<R>> {
+    abstract override _handle(_payload: T, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit): Promise<StreamPacket<R>>;
+}

src/onebot/action/stream/TestStreamDownload.ts

@@ -0,0 +1,32 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction, OneBotRequestToolkit } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+
+const SchemaData = Type.Object({
+    error: Type.Optional(Type.Boolean({ default: false }))
+});
+
+type Payload = Static<typeof SchemaData>;
+
+export class TestDownloadStream extends OneBotAction<Payload, StreamPacket<{ data: string }>> {
+    override actionName = ActionName.TestDownloadStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    async _handle(_payload: Payload, _adaptername: string, _config: NetworkAdapterConfig, req: OneBotRequestToolkit) {
+        for (let i = 0; i < 10; i++) {
+            await req.send({ type: StreamStatus.Stream, data: `Index-> ${i + 1}`, data_type: 'data_chunk' });
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if( _payload.error ){
+            throw new Error('This is a test error');
+        }
+        return {
+            type: StreamStatus.Response,
+            data_type: 'data_complete',
+            data: 'Stream transmission complete'
+        };
+    }
+}

src/onebot/action/stream/UploadFileStream.ts

@@ -0,0 +1,346 @@
+import { ActionName } from '@/onebot/action/router';
+import { OneBotAction } from '@/onebot/action/OneBotAction';
+import { Static, Type } from '@sinclair/typebox';
+import { NetworkAdapterConfig } from '@/onebot/config/config';
+import { StreamPacket, StreamStatus } from './StreamBasic';
+import fs from 'fs';
+import { join as joinPath } from 'node:path';
+import { randomUUID } from 'crypto';
+import { createHash } from 'crypto';
+import { unlink } from 'node:fs';
+
+// 简化配置
+const CONFIG = {
+    TIMEOUT: 10 * 60 * 1000,           // 10分钟超时
+    MEMORY_THRESHOLD: 10 * 1024 * 1024, // 10MB，超过使用磁盘
+    MEMORY_LIMIT: 100 * 1024 * 1024     // 100MB内存总限制
+} as const;
+
+const SchemaData = Type.Object({
+    stream_id: Type.String(),
+    chunk_data: Type.Optional(Type.String()),
+    chunk_index: Type.Optional(Type.Number()),
+    total_chunks: Type.Optional(Type.Number()),
+    file_size: Type.Optional(Type.Number()),
+    expected_sha256: Type.Optional(Type.String()),
+    is_complete: Type.Optional(Type.Boolean()),
+    filename: Type.Optional(Type.String()),
+    reset: Type.Optional(Type.Boolean()),
+    verify_only: Type.Optional(Type.Boolean()),
+    file_retention: Type.Number({ default: 5 * 60 * 1000 }) // 默认5分钟 回收 不设置或0为不回收
+});
+
+type Payload = Static<typeof SchemaData>;
+
+// 简化流状态接口
+interface StreamState {
+    id: string;
+    filename: string;
+    totalChunks: number;
+    receivedChunks: number;
+    missingChunks: Set<number>;
+
+    // 可选属性
+    fileSize?: number;
+    expectedSha256?: string;
+
+    // 存储策略
+    useMemory: boolean;
+    memoryChunks?: Map<number, Buffer>;
+    tempDir?: string;
+    finalPath?: string;
+    fileRetention?: number;
+
+    // 管理
+    createdAt: number;
+    timeoutId: NodeJS.Timeout;
+}
+
+interface StreamResult {
+    stream_id: string;
+    status: 'file_created' | 'chunk_received' | 'file_complete';
+    received_chunks: number;
+    total_chunks: number;
+    file_path?: string;
+    file_size?: number;
+    sha256?: string;
+}
+
+export class UploadFileStream extends OneBotAction<Payload, StreamPacket<StreamResult>> {
+    override actionName = ActionName.UploadFileStream;
+    override payloadSchema = SchemaData;
+    override useStream = true;
+
+    private static streams = new Map<string, StreamState>();
+    private static memoryUsage = 0;
+
+    async _handle(payload: Payload, _adaptername: string, _config: NetworkAdapterConfig): Promise<StreamPacket<StreamResult>> {
+        const { stream_id, reset, verify_only } = payload;
+
+        if (reset) {
+            this.cleanupStream(stream_id);
+            throw new Error('Stream reset completed');
+        }
+
+        if (verify_only) {
+            const stream = UploadFileStream.streams.get(stream_id);
+            if (!stream) throw new Error('Stream not found');
+            return this.getStreamStatus(stream);
+        }
+
+        const stream = this.getOrCreateStream(payload);
+
+        if (payload.chunk_data && payload.chunk_index !== undefined) {
+            return await this.processChunk(stream, payload.chunk_data, payload.chunk_index);
+        }
+
+        if (payload.is_complete || stream.receivedChunks === stream.totalChunks) {
+            return await this.completeStream(stream);
+        }
+
+        return this.getStreamStatus(stream);
+    }
+
+
+
+    private getOrCreateStream(payload: Payload): StreamState {
+        let stream = UploadFileStream.streams.get(payload.stream_id);
+
+        if (!stream) {
+            if (!payload.total_chunks) {
+                throw new Error('total_chunks required for new stream');
+            }
+            stream = this.createStream(payload);
+        }
+
+        return stream;
+    }
+
+    private createStream(payload: Payload): StreamState {
+        const { stream_id, total_chunks, file_size, filename, expected_sha256 } = payload;
+
+        const useMemory = this.shouldUseMemory(file_size);
+        if (useMemory && file_size && (UploadFileStream.memoryUsage + file_size) > CONFIG.MEMORY_LIMIT) {
+            throw new Error('Memory limit exceeded');
+        }
+
+        const stream: StreamState = {
+            id: stream_id,
+            filename: filename || `upload_${randomUUID()}`,
+            totalChunks: total_chunks!,
+            receivedChunks: 0,
+            missingChunks: new Set(Array.from({ length: total_chunks! }, (_, i) => i)),
+            fileSize: file_size,
+            expectedSha256: expected_sha256,
+            useMemory,
+            createdAt: Date.now(),
+            timeoutId: this.setupTimeout(stream_id),
+            fileRetention: payload.file_retention
+        };
+        try {
+            if (useMemory) {
+                stream.memoryChunks = new Map();
+                if (file_size) UploadFileStream.memoryUsage += file_size;
+            } else {
+                this.setupDiskStorage(stream);
+            }
+
+            UploadFileStream.streams.set(stream_id, stream);
+            return stream;
+        } catch (error) {
+            // 如果设置存储失败，清理已创建的资源
+            clearTimeout(stream.timeoutId);
+            if (stream.tempDir && fs.existsSync(stream.tempDir)) {
+                try {
+                    fs.rmSync(stream.tempDir, { recursive: true, force: true });
+                } catch (cleanupError) {
+                    console.error(`Failed to cleanup temp dir during creation error:`, cleanupError);
+                }
+            }
+            throw error;
+        }
+    }
+
+    private shouldUseMemory(fileSize?: number): boolean {
+        return fileSize !== undefined && fileSize <= CONFIG.MEMORY_THRESHOLD;
+    }
+
+    private setupDiskStorage(stream: StreamState): void {
+        const tempDir = joinPath(this.core.NapCatTempPath, `upload_${stream.id}`);
+        const finalPath = joinPath(this.core.NapCatTempPath, stream.filename);
+
+        fs.mkdirSync(tempDir, { recursive: true });
+
+        stream.tempDir = tempDir;
+        stream.finalPath = finalPath;
+    }
+
+    private setupTimeout(streamId: string): NodeJS.Timeout {
+        return setTimeout(() => {
+            console.log(`Stream ${streamId} timeout`);
+            this.cleanupStream(streamId);
+        }, CONFIG.TIMEOUT);
+    }
+
+    private async processChunk(stream: StreamState, chunkData: string, chunkIndex: number): Promise<StreamPacket<StreamResult>> {
+        // 验证索引
+        if (chunkIndex < 0 || chunkIndex >= stream.totalChunks) {
+            throw new Error(`Invalid chunk index: ${chunkIndex}`);
+        }
+
+        // 检查重复
+        if (!stream.missingChunks.has(chunkIndex)) {
+            return this.getStreamStatus(stream);
+        }
+
+        const buffer = Buffer.from(chunkData, 'base64');
+
+        // 存储分片
+        if (stream.useMemory) {
+            stream.memoryChunks!.set(chunkIndex, buffer);
+        } else {
+            const chunkPath = joinPath(stream.tempDir!, `${chunkIndex}.chunk`);
+            await fs.promises.writeFile(chunkPath, buffer);
+        }
+
+        // 更新状态
+        stream.missingChunks.delete(chunkIndex);
+        stream.receivedChunks++;
+        this.refreshTimeout(stream);
+
+        return {
+            type: StreamStatus.Stream,
+            stream_id: stream.id,
+            status: 'chunk_received',
+            received_chunks: stream.receivedChunks,
+            total_chunks: stream.totalChunks
+        };
+    }
+
+    private refreshTimeout(stream: StreamState): void {
+        clearTimeout(stream.timeoutId);
+        stream.timeoutId = this.setupTimeout(stream.id);
+    }
+
+    private getStreamStatus(stream: StreamState): StreamPacket<StreamResult> {
+        return {
+            type: StreamStatus.Stream,
+            stream_id: stream.id,
+            status: 'file_created',
+            received_chunks: stream.receivedChunks,
+            total_chunks: stream.totalChunks
+        };
+    }
+
+    private async completeStream(stream: StreamState): Promise<StreamPacket<StreamResult>> {
+        // 合并分片
+        const finalBuffer = stream.useMemory ?
+            await this.mergeMemoryChunks(stream) :
+            await this.mergeDiskChunks(stream);
+
+        // 验证SHA256
+        const sha256 = this.validateSha256(stream, finalBuffer);
+
+        // 保存文件
+        const finalPath = stream.finalPath || joinPath(this.core.NapCatTempPath, stream.filename);
+        await fs.promises.writeFile(finalPath, finalBuffer);
+
+        // 清理资源但保留文件
+        this.cleanupStream(stream.id, false);
+        if (stream.fileRetention && stream.fileRetention > 0) {
+            setTimeout(() => {
+                unlink(finalPath, err => {
+                    if (err) this.core.context.logger.logError(`Failed to delete retained file ${finalPath}:`, err);
+                });
+            }, stream.fileRetention);
+        }
+        return {
+            type: StreamStatus.Response,
+            stream_id: stream.id,
+            status: 'file_complete',
+            received_chunks: stream.receivedChunks,
+            total_chunks: stream.totalChunks,
+            file_path: finalPath,
+            file_size: finalBuffer.length,
+            sha256
+        };
+    }
+
+    private async mergeMemoryChunks(stream: StreamState): Promise<Buffer> {
+        const chunks: Buffer[] = [];
+        for (let i = 0; i < stream.totalChunks; i++) {
+            const chunk = stream.memoryChunks!.get(i);
+            if (!chunk) throw new Error(`Missing memory chunk ${i}`);
+            chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+    }
+
+    private async mergeDiskChunks(stream: StreamState): Promise<Buffer> {
+        const chunks: Buffer[] = [];
+        for (let i = 0; i < stream.totalChunks; i++) {
+            const chunkPath = joinPath(stream.tempDir!, `${i}.chunk`);
+            if (!fs.existsSync(chunkPath)) throw new Error(`Missing chunk file ${i}`);
+            chunks.push(await fs.promises.readFile(chunkPath));
+        }
+        return Buffer.concat(chunks);
+    }
+
+    private validateSha256(stream: StreamState, buffer: Buffer): string | undefined {
+        if (!stream.expectedSha256) return undefined;
+
+        const actualSha256 = createHash('sha256').update(buffer).digest('hex');
+        if (actualSha256 !== stream.expectedSha256) {
+            throw new Error(`SHA256 mismatch. Expected: ${stream.expectedSha256}, Got: ${actualSha256}`);
+        }
+        return actualSha256;
+    }
+
+    private cleanupStream(streamId: string, deleteFinalFile = true): void {
+        const stream = UploadFileStream.streams.get(streamId);
+        if (!stream) return;
+
+        try {
+            // 清理超时
+            clearTimeout(stream.timeoutId);
+
+            // 清理内存
+            if (stream.useMemory) {
+                if (stream.fileSize) {
+                    UploadFileStream.memoryUsage = Math.max(0, UploadFileStream.memoryUsage - stream.fileSize);
+                }
+                stream.memoryChunks?.clear();
+            }
+
+            // 清理临时文件夹及其所有内容
+            if (stream.tempDir) {
+                try {
+                    if (fs.existsSync(stream.tempDir)) {
+                        fs.rmSync(stream.tempDir, { recursive: true, force: true });
+                        console.log(`Cleaned up temp directory: ${stream.tempDir}`);
+                    }
+                } catch (error) {
+                    console.error(`Failed to cleanup temp directory ${stream.tempDir}:`, error);
+                }
+            }
+
+            // 删除最终文件（如果需要）
+            if (deleteFinalFile && stream.finalPath) {
+                try {
+                    if (fs.existsSync(stream.finalPath)) {
+                        fs.unlinkSync(stream.finalPath);
+                        console.log(`Deleted final file: ${stream.finalPath}`);
+                    }
+                } catch (error) {
+                    console.error(`Failed to delete final file ${stream.finalPath}:`, error);
+                }
+            }
+
+        } catch (error) {
+            console.error(`Cleanup error for stream ${streamId}:`, error);
+        } finally {
+            UploadFileStream.streams.delete(streamId);
+            console.log(`Stream ${streamId} cleaned up`);
+        }
+    }
+}

src/onebot/action/stream/test_upload_stream.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+NapCat OneBot WebSocket 文件流上传测试脚本
+用于测试 UploadFileStream 接口的一次性分片上传功能
+"""
+
+import asyncio
+import json
+import base64
+import hashlib
+import os
+import uuid
+from typing import List, Optional
+import websockets
+import argparse
+from pathlib import Path
+
+class OneBotUploadTester:
+    def __init__(self, ws_url: str = "ws://localhost:3001", access_token: Optional[str] = None):
+        self.ws_url = ws_url
+        self.access_token = access_token
+        self.websocket = None
+        
+    async def connect(self):
+        """连接到 OneBot WebSocket"""
+        headers = {}
+        if self.access_token:
+            headers["Authorization"] = f"Bearer {self.access_token}"
+            
+        print(f"连接到 {self.ws_url}")
+        self.websocket = await websockets.connect(self.ws_url, additional_headers=headers)
+        print("WebSocket 连接成功")
+        
+    async def disconnect(self):
+        """断开 WebSocket 连接"""
+        if self.websocket:
+            await self.websocket.close()
+            print("WebSocket 连接已断开")
+            
+    def calculate_file_chunks(self, file_path: str, chunk_size: int = 64) -> tuple[List[bytes], str, int]:
+        """
+        计算文件分片和 SHA256
+        
+        Args:
+            file_path: 文件路径
+            chunk_size: 分片大小（默认64KB）
+            
+        Returns:
+            (chunks, sha256_hash, total_size)
+        """
+        chunks = []
+        hasher = hashlib.sha256()
+        total_size = 0
+        
+        with open(file_path, 'rb') as f:
+            while True:
+                chunk = f.read(chunk_size)
+                if not chunk:
+                    break
+                chunks.append(chunk)
+                hasher.update(chunk)
+                total_size += len(chunk)
+                
+        sha256_hash = hasher.hexdigest()
+        print(f"文件分析完成:")
+        print(f"  - 文件大小: {total_size} 字节")
+        print(f"  - 分片数量: {len(chunks)}")
+        print(f"  - SHA256: {sha256_hash}")
+        
+        return chunks, sha256_hash, total_size
+    
+    async def send_action(self, action: str, params: dict, echo: str = None) -> dict:
+        """发送 OneBot 动作请求"""
+        if not echo:
+            echo = str(uuid.uuid4())
+            
+        message = {
+            "action": action,
+            "params": params,
+            "echo": echo
+        }
+        
+        print(f"发送请求: {action}")
+        await self.websocket.send(json.dumps(message))
+        
+        # 等待响应
+        while True:
+            response = await self.websocket.recv()
+            data = json.loads(response)
+            
+            # 检查是否是我们的响应
+            if data.get("echo") == echo:
+                return data
+            else:
+                # 可能是其他消息，继续等待
+                print(f"收到其他消息: {data}")
+                continue
+    
+    async def upload_file_stream_batch(self, file_path: str, chunk_size: int = 64 ) -> str:
+        """
+        一次性批量上传文件流
+        
+        Args:
+            file_path: 要上传的文件路径
+            chunk_size: 分片大小
+            
+        Returns:
+            上传完成后的文件路径
+        """
+        file_path = Path(file_path)
+        if not file_path.exists():
+            raise FileNotFoundError(f"文件不存在: {file_path}")
+            
+        # 分析文件
+        chunks, sha256_hash, total_size = self.calculate_file_chunks(str(file_path), chunk_size)
+        stream_id = str(uuid.uuid4())
+        
+        print(f"\n开始上传文件: {file_path.name}")
+        print(f"流ID: {stream_id}")
+        
+        # 一次性发送所有分片
+        total_chunks = len(chunks)
+        
+        for chunk_index, chunk_data in enumerate(chunks):
+            # 将分片数据编码为 base64
+            chunk_base64 = base64.b64encode(chunk_data).decode('utf-8')
+            
+            # 构建参数
+            params = {
+                "stream_id": stream_id,
+                "chunk_data": chunk_base64,
+                "chunk_index": chunk_index,
+                "total_chunks": total_chunks,
+                "file_size": total_size,
+                "expected_sha256": sha256_hash,
+                "filename": file_path.name,
+                "file_retention": 30 * 1000
+            }
+            
+            # 发送分片
+            response = await self.send_action("upload_file_stream", params)
+            
+            if response.get("status") != "ok":
+                raise Exception(f"上传分片 {chunk_index} 失败: {response}")
+                
+            # 解析流响应
+            stream_data = response.get("data", {})
+            print(f"分片 {chunk_index + 1}/{total_chunks} 上传成功 "
+                  f"(接收: {stream_data.get('received_chunks', 0)}/{stream_data.get('total_chunks', 0)})")
+        
+        # 发送完成信号
+        print(f"\n所有分片发送完成，请求文件合并...")
+        complete_params = {
+            "stream_id": stream_id,
+            "is_complete": True
+        }
+        
+        response = await self.send_action("upload_file_stream", complete_params)
+        
+        if response.get("status") != "ok":
+            raise Exception(f"文件合并失败: {response}")
+            
+        result = response.get("data", {})
+        
+        if result.get("status") == "file_complete":
+            print(f"✅ 文件上传成功!")
+            print(f"  - 文件路径: {result.get('file_path')}")
+            print(f"  - 文件大小: {result.get('file_size')} 字节")
+            print(f"  - SHA256: {result.get('sha256')}")
+            return result.get('file_path')
+        else:
+            raise Exception(f"文件状态异常: {result}")
+    
+    async def test_upload(self, file_path: str, chunk_size: int = 64 ):
+        """测试文件上传"""
+        try:
+            await self.connect()
+            
+            # 执行上传
+            uploaded_path = await self.upload_file_stream_batch(file_path, chunk_size)
+            
+            print(f"\n🎉 测试完成! 上传后的文件路径: {uploaded_path}")
+            
+        except Exception as e:
+            print(f"❌ 测试失败: {e}")
+            raise
+        finally:
+            await self.disconnect()
+
+def create_test_file(file_path: str, size_mb: float = 1):
+    """创建测试文件"""
+    size_bytes = int(size_mb * 1024 * 1024)
+    
+    with open(file_path, 'wb') as f:
+        # 写入一些有意义的测试数据
+        test_data = b"NapCat Upload Test Data - " * 100
+        written = 0
+        while written < size_bytes:
+            write_size = min(len(test_data), size_bytes - written)
+            f.write(test_data[:write_size])
+            written += write_size
+    
+    print(f"创建测试文件: {file_path} ({size_mb}MB)")
+
+async def main():
+    parser = argparse.ArgumentParser(description="NapCat OneBot 文件流上传测试")
+    parser.add_argument("--url", default="ws://localhost:3001", help="WebSocket URL")
+    parser.add_argument("--token", help="访问令牌")
+    parser.add_argument("--file", help="要上传的文件路径")
+    parser.add_argument("--chunk-size", type=int, default=64*1024, help="分片大小(字节)")
+    parser.add_argument("--create-test", type=float, help="创建测试文件(MB)")
+    
+    args = parser.parse_args()
+    
+    # 创建测试文件
+    if args.create_test:
+        test_file = "test_upload_file.bin"
+        create_test_file(test_file, args.create_test)
+        if not args.file:
+            args.file = test_file
+    
+    if not args.file:
+        print("请指定要上传的文件路径，或使用 --create-test 创建测试文件")
+        return
+    
+    # 创建测试器并运行
+    tester = OneBotUploadTester(args.url, args.token)
+    await tester.test_upload(args.file, args.chunk_size)
+
+if __name__ == "__main__":
+    # 安装依赖提示
+    try:
+        import websockets
+    except ImportError:
+        print("请先安装依赖: pip install websockets")
+        exit(1)
+    
+    asyncio.run(main())

src/onebot/api/msg.ts

@@ -578,7 +578,7 @@ export class OneBotMsgApi {
                 };
             }
 
-            if (!context.peer || context.peer.chatType == ChatType.KCHATTYPEC2C) return undefined;
+            if (!context.peer || !atQQ || context.peer.chatType == ChatType.KCHATTYPEC2C) return undefined; // 过滤掉空atQQ
             if (atQQ === 'all') return at(atQQ, atQQ, NTMsgAtType.ATTYPEALL, '全体成员');
             const atMember = await this.core.apis.GroupApi.getGroupMember(context.peer.peerUid, atQQ);
             if (atMember) {
@@ -1124,10 +1124,13 @@ export class OneBotMsgApi {
             if (ignoreTypes.includes(sendMsg.type)) {
                 continue;
             }
-            const converter = this.ob11ToRawConverters[sendMsg.type] as (
+            const converter = this.ob11ToRawConverters[sendMsg.type] as ((
                 sendMsg: Extract<OB11MessageData, { type: OB11MessageData['type'] }>,
                 context: SendMessageContext,
-            ) => Promise<SendMessageElement | undefined>;
+            ) => Promise<SendMessageElement | undefined>) | undefined;
+            if (converter == undefined) {
+                throw new Error('未知的消息类型：' + sendMsg.type);
+            }
             const callResult = converter(
                 sendMsg,
                 { peer, deleteAfterSentFiles },

src/onebot/index.ts

@@ -17,6 +17,7 @@ import {
     NTMsgAtType,
 } from '@/core';
 import { OB11ConfigLoader } from '@/onebot/config';
+import { pendingTokenToSend } from '@/webui/index';
 import {
     OB11HttpClientAdapter,
     OB11WebSocketClientAdapter,
@@ -64,8 +65,8 @@ export class NapCatOneBot11Adapter {
     networkManager: OB11NetworkManager;
     actions: ActionMap;
     private readonly bootTime = Date.now() / 1000;
-    recallEventCache = new Map<string, any>();
-    constructor(core: NapCatCore, context: InstanceContext, pathWrapper: NapCatPathWrapper) {
+    recallEventCache = new Map<string, NodeJS.Timeout>();
+    constructor (core: NapCatCore, context: InstanceContext, pathWrapper: NapCatPathWrapper) {
         this.core = core;
         this.context = context;
         this.configLoader = new OB11ConfigLoader(core, pathWrapper.configPath, OneBotConfigSchema);
@@ -79,7 +80,7 @@ export class NapCatOneBot11Adapter {
         this.actions = createActionMap(this, core);
         this.networkManager = new OB11NetworkManager();
     }
-    async creatOneBotLog(ob11Config: OneBotConfig) {
+    async creatOneBotLog (ob11Config: OneBotConfig) {
         let log = '[network] 配置加载\n';
         for (const key of ob11Config.network.httpServers) {
             log += `HTTP服务: ${key.host}:${key.port}, : ${key.enable ? '已启动' : '未启动'}\n`;
@@ -98,15 +99,43 @@ export class NapCatOneBot11Adapter {
         }
         return log;
     }
-    async InitOneBot() {
+    async InitOneBot () {
         const selfInfo = this.core.selfInfo;
         const ob11Config = this.configLoader.configData;
-
         this.core.apis.UserApi.getUserDetailInfo(selfInfo.uid, false)
-            .then((user) => {
+            .then(async (user) => {
                 selfInfo.nick = user.nick;
                 this.context.logger.setLogSelfInfo(selfInfo);
-                        WebUiDataRuntime.getQQLoginCallback()(true);
+                
+                // 检查是否有待发送的token
+                if (pendingTokenToSend) {
+                    this.context.logger.log('[NapCat] [OneBot] 🔐 检测到待发送的WebUI Token，开始发送');
+                    try {
+                        await this.core.apis.MsgApi.sendMsg(
+                            { chatType: ChatType.KCHATTYPEC2C, peerUid: selfInfo.uid, guildId: '' },
+                            [{
+                                elementType: ElementType.TEXT,
+                                elementId: '',
+                                textElement: {
+                                    content: 
+                                    '[NapCat] 温馨提示:\n'+
+                                    'WebUI密码为默认密码，已进行强制修改\n'+
+                                    '新密码: ' +pendingTokenToSend,
+                                    atType: NTMsgAtType.ATTYPEUNKNOWN,
+                                    atUid: '',
+                                    atTinyId: '',
+                                    atNtUid: '',
+                                }
+                            }],
+                            5000
+                        );
+                        this.context.logger.log('[NapCat] [OneBot] ✅ WebUI Token 消息发送成功');
+                    } catch (error) {
+                        this.context.logger.logError('[NapCat] [OneBot] ❌ WebUI Token 消息发送失败:', error);
+                    }
+                }
+                
+                WebUiDataRuntime.getQQLoginCallback()(true);
             })
             .catch(e => this.context.logger.logError(e));
 
@@ -120,7 +149,7 @@ export class NapCatOneBot11Adapter {
         //     new OB11PluginAdapter('myPlugin', this.core, this,this.actions)
         // );
         if (existsSync(this.context.pathWrapper.pluginPath)) {
-            this.context.logger.log(`[Plugins] 插件目录存在，开始加载插件`);
+            this.context.logger.log('[Plugins] 插件目录存在，开始加载插件');
             this.networkManager.registerAdapter(
                 new OB11PluginMangerAdapter('plugin_manager', this.core, this, this.actions)
             );
@@ -181,25 +210,6 @@ export class NapCatOneBot11Adapter {
         WebUiDataRuntime.setQQVersion(this.core.context.basicInfoWrapper.getFullQQVersion());
         WebUiDataRuntime.setQQLoginInfo(selfInfo);
         WebUiDataRuntime.setQQLoginStatus(true);
-
-        let sendWebUiToken = async (token: string) => {
-            await this.core.apis.MsgApi.sendMsg(
-                { chatType: ChatType.KCHATTYPEC2C, peerUid: selfInfo.uid, guildId: '' },
-                [{
-                    elementType: ElementType.TEXT,
-                    elementId: '',
-                    textElement: {
-                        content: 'Update WebUi Token: ' + token,
-                        atType: NTMsgAtType.ATTYPEUNKNOWN,
-                        atUid: '',
-                        atTinyId: '',
-                        atNtUid: '',
-                    }
-                }],
-                5000
-            )
-        };
-        WebUiDataRuntime.setWebUiTokenChangeCallback(sendWebUiToken);
         WebUiDataRuntime.setOnOB11ConfigChanged(async (newConfig) => {
             const prev = this.configLoader.configData;
             this.configLoader.save(newConfig);
@@ -209,7 +219,7 @@ export class NapCatOneBot11Adapter {
     }
 
 
-    private async reloadNetwork(prev: OneBotConfig, now: OneBotConfig): Promise<void> {
+    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}`);
@@ -222,7 +232,7 @@ export class NapCatOneBot11Adapter {
         await this.handleConfigChange(prev.network.websocketClients, now.network.websocketClients, OB11WebSocketClientAdapter);
     }
 
-    private async handleConfigChange<CT extends NetworkAdapterConfig>(
+    private async handleConfigChange<CT extends NetworkAdapterConfig> (
         prevConfig: NetworkAdapterConfig[],
         nowConfig: NetworkAdapterConfig[],
         adapterClass: new (
@@ -254,7 +264,7 @@ export class NapCatOneBot11Adapter {
         }
     }
 
-    private initMsgListener() {
+    private initMsgListener () {
         const msgListener = new NodeIKernelMsgListener();
         msgListener.onRecvSysMsg = (msg) => {
             this.apis.MsgApi.parseSysMessage(msg)
@@ -368,7 +378,7 @@ export class NapCatOneBot11Adapter {
         this.context.session.getMsgService().addKernelMsgListener(proxiedListenerOf(msgListener, this.context.logger));
     }
 
-    private initBuddyListener() {
+    private initBuddyListener () {
         const buddyListener = new NodeIKernelBuddyListener();
 
         buddyListener.onBuddyReqChange = async (reqs) => {
@@ -399,7 +409,7 @@ export class NapCatOneBot11Adapter {
             .addKernelBuddyListener(proxiedListenerOf(buddyListener, this.context.logger));
     }
 
-    private initGroupListener() {
+    private initGroupListener () {
         const groupListener = new NodeIKernelGroupListener();
 
         groupListener.onGroupNotifiesUpdated = async (_, notifies) => {
@@ -492,7 +502,7 @@ export class NapCatOneBot11Adapter {
             .addKernelGroupListener(proxiedListenerOf(groupListener, this.context.logger));
     }
 
-    private async emitMsg(message: RawMessage) {
+    private async emitMsg (message: RawMessage) {
         const network = await this.networkManager.getAllConfig();
         this.context.logger.logDebug('收到新消息 RawMessage', message);
         await Promise.allSettled([
@@ -501,7 +511,7 @@ export class NapCatOneBot11Adapter {
         ]);
     }
 
-    private async handleMsg(message: RawMessage, network: Array<NetworkAdapterConfig>) {
+    private async handleMsg (message: RawMessage, network: Array<NetworkAdapterConfig>) {
         // 过滤无效消息
         if (message.msgType === NTMsgType.KMSGTYPENULL) {
             return;
@@ -522,17 +532,17 @@ export class NapCatOneBot11Adapter {
         }
     }
 
-    private isSelfMessage(ob11Msg: {
-        stringMsg: OB11Message;
-        arrayMsg: OB11Message;
+    private isSelfMessage (ob11Msg: {
+        stringMsg: OB11Message
+        arrayMsg: OB11Message
     }): boolean {
         return ob11Msg.stringMsg.user_id.toString() == this.core.selfInfo.uin ||
             ob11Msg.arrayMsg.user_id.toString() == this.core.selfInfo.uin;
     }
 
-    private createMsgMap(network: Array<NetworkAdapterConfig>, ob11Msg: {
-        stringMsg: OB11Message;
-        arrayMsg: OB11Message;
+    private createMsgMap (network: Array<NetworkAdapterConfig>, ob11Msg: {
+        stringMsg: OB11Message
+        arrayMsg: OB11Message
     }, isSelfMsg: boolean, message: RawMessage): Map<string, OB11Message> {
         const msgMap: Map<string, OB11Message> = new Map();
         network.filter(e => e.enable).forEach(e => {
@@ -550,7 +560,7 @@ export class NapCatOneBot11Adapter {
         return msgMap;
     }
 
-    private handleDebugNetwork(network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, message: RawMessage) {
+    private handleDebugNetwork (network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, message: RawMessage) {
         const debugNetwork = network.filter(e => e.enable && e.debug);
         if (debugNetwork.length > 0) {
             debugNetwork.forEach(adapter => {
@@ -564,7 +574,7 @@ export class NapCatOneBot11Adapter {
         }
     }
 
-    private handleNotReportSelfNetwork(network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, isSelfMsg: boolean) {
+    private handleNotReportSelfNetwork (network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, isSelfMsg: boolean) {
         if (isSelfMsg) {
             const notReportSelfNetwork = network.filter(e => e.enable && (('reportSelfMessage' in e && !e.reportSelfMessage) || !('reportSelfMessage' in e)));
             notReportSelfNetwork.forEach(adapter => {
@@ -573,7 +583,7 @@ export class NapCatOneBot11Adapter {
         }
     }
 
-    private async handleGroupEvent(message: RawMessage) {
+    private async handleGroupEvent (message: RawMessage) {
         try {
             // 群名片修改事件解析 任何都该判断
             if (message.senderUin && message.senderUin !== '0') {
@@ -606,7 +616,7 @@ export class NapCatOneBot11Adapter {
         }
     }
 
-    private async handlePrivateMsgEvent(message: RawMessage) {
+    private async handlePrivateMsgEvent (message: RawMessage) {
         try {
             if (message.msgType === NTMsgType.KMSGTYPEGRAYTIPS) {
                 // 灰条为单元素消息
@@ -624,7 +634,7 @@ export class NapCatOneBot11Adapter {
         }
     }
 
-    private async emitRecallMsg(message: RawMessage, element: MessageElement) {
+    private async emitRecallMsg (message: RawMessage, element: MessageElement) {
         const peer: Peer = { chatType: message.chatType, peerUid: message.peerUid, guildId: '' };
         const oriMessageId = MessageUnique.getShortIdByMsgId(message.msgId) ?? MessageUnique.createUniqueMsgId(peer, message.msgId);
         if (message.chatType == ChatType.KCHATTYPEC2C) {
@@ -635,7 +645,7 @@ export class NapCatOneBot11Adapter {
         return;
     }
 
-    private async emitFriendRecallMsg(message: RawMessage, oriMessageId: number, element: MessageElement) {
+    private async emitFriendRecallMsg (message: RawMessage, oriMessageId: number, element: MessageElement) {
         const operatorUid = element.grayTipElement?.revokeElement.operatorUid;
         if (!operatorUid) return undefined;
         return new OB11FriendRecallNoticeEvent(
@@ -645,7 +655,7 @@ export class NapCatOneBot11Adapter {
         );
     }
 
-    private async emitGroupRecallMsg(message: RawMessage, oriMessageId: number, element: MessageElement) {
+    private async emitGroupRecallMsg (message: RawMessage, oriMessageId: number, element: MessageElement) {
         const operatorUid = element.grayTipElement?.revokeElement.operatorUid;
         if (!operatorUid) return undefined;
         const operatorId = await this.core.apis.UserApi.getUinByUidV2(operatorUid);

src/onebot/network/adapter.ts

@@ -23,7 +23,7 @@ export abstract class IOB11NetworkAdapter<CT extends NetworkAdapterConfig> {
         this.logger = core.context.logger;
     }
 
-    abstract onEvent<T extends OB11EmitEventContent>(event: T): void;
+    abstract onEvent<T extends OB11EmitEventContent>(event: T): Promise<void>;
 
     abstract open(): void | Promise<void>;
 

src/onebot/network/http-client.ts

@@ -16,7 +16,7 @@ export class OB11HttpClientAdapter extends IOB11NetworkAdapter<HttpClientConfig>
         super(name, config, core, obContext, actions);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         this.emitEventAsync(event).catch(e => this.logger.logError('[OneBot] [Http Client] 新消息事件HTTP上报返回快速操作失败', e));
     }
 

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

@@ -9,7 +9,7 @@ export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
         if (req.path === '/_events') {
             this.createSseSupport(req, res);
         } else {
-            super.httpApiRequest(req, res);
+            super.httpApiRequest(req, res, true);
         }
     }
 
@@ -23,11 +23,22 @@ export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
         req.on('close', () => {
             this.sseClients = this.sseClients.filter((client) => client !== res);
         });
+
     }
 
-    override onEvent<T extends OB11EmitEventContent>(event: T) {
+    override async onEvent<T extends OB11EmitEventContent>(event: T) {
+        let promises: Promise<void>[] = [];
         this.sseClients.forEach((res) => {
-            res.write(`data: ${JSON.stringify(event)}\n\n`);
+            promises.push(new Promise<void>((resolve, reject) => {
+                res.write(`data: ${JSON.stringify(event)}\n\n`, (err) => {
+                    if (err) {
+                        reject(err);
+                    } else {
+                        resolve();
+                    }
+                });
+            }));
         });
+        await Promise.allSettled(promises);
     }
 }

src/onebot/network/http-server.ts

@@ -20,7 +20,7 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
     }
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    override onEvent<T extends OB11EmitEventContent>(_event: T) {
+    override async onEvent<T extends OB11EmitEventContent>(_event: T) {
         // http server is passive, no need to emit event
     }
 
@@ -104,7 +104,7 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
         }
     }
 
-    async httpApiRequest(req: Request, res: Response) {
+    async httpApiRequest(req: Request, res: Response, request_sse: boolean = false) {
         let payload = req.body;
         if (req.method == 'get') {
             payload = req.query;
@@ -117,17 +117,35 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
             return res.json(hello);
         }
         const actionName = req.path.split('/')[1];
+        const payload_echo = payload['echo'];
+        const real_echo = payload_echo ?? Math.random().toString(36).substring(2, 15);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const action = this.actions.get(actionName as any);
         if (action) {
+            const useStream = action.useStream;
             try {
-                const result = await action.handle(payload, this.name, this.config);
+                const result = await action.handle(payload, this.name, this.config, {
+                    send: request_sse ? async (data: object) => {
+                        await this.onEvent({ ...OB11Response.ok(data, real_echo, true) } as unknown as OB11EmitEventContent);
+                    } : async (data: object) => {
+                        let newPromise = new Promise<void>((resolve, _reject) => {
+                            res.write(JSON.stringify({ ...OB11Response.ok(data, real_echo, true) }) + "\r\n\r\n", () => {
+                                resolve();
+                            });
+                        });
+                        return newPromise;
+                    }
+                }, real_echo);
+                if (useStream) {
+                    res.write(JSON.stringify({ ...result }) + "\r\n\r\n");
+                    return res.end();
+                };
                 return res.json(result);
             } catch (error: unknown) {
-                return res.json(OB11Response.error((error as Error)?.stack?.toString() || (error as Error)?.message || 'Error Handle', 200));
+                return res.json(OB11Response.error((error as Error)?.stack?.toString() || (error as Error)?.message || 'Error Handle', 200, real_echo));
             }
         } else {
-            return res.json(OB11Response.error('不支持的Api ' + actionName, 200));
+            return res.json(OB11Response.error('不支持的Api ' + actionName, 200, real_echo));
         }
     }
 

src/onebot/network/index.ts

@@ -20,9 +20,9 @@ export class OB11NetworkManager {
     }
 
     async emitEvent(event: OB11EmitEventContent) {
-        return Promise.all(Array.from(this.adapters.values()).map(adapter => {
+        return Promise.all(Array.from(this.adapters.values()).map(async adapter => {
             if (adapter.isEnable) {
-                return adapter.onEvent(event);
+                return await adapter.onEvent(event);
             }
         }));
     }
@@ -32,19 +32,19 @@ export class OB11NetworkManager {
     }
 
     async emitEventByName(names: string[], event: OB11EmitEventContent) {
-        return Promise.all(names.map(name => {
+        return Promise.all(names.map(async name => {
             const adapter = this.adapters.get(name);
             if (adapter && adapter.isEnable) {
-                return adapter.onEvent(event);
+                return await adapter.onEvent(event);
             }
         }));
     }
 
     async emitEventByNames(map: Map<string, OB11EmitEventContent>) {
-        return Promise.all(Array.from(map.entries()).map(([name, event]) => {
+        return Promise.all(Array.from(map.entries()).map(async ([name, event]) => {
             const adapter = this.adapters.get(name);
             if (adapter && adapter.isEnable) {
-                return adapter.onEvent(event);
+                return await adapter.onEvent(event);
             }
         }));
     }

src/onebot/network/plugin-manger.ts

@@ -251,14 +251,20 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
         this.logger.log(`[Plugin Adapter] Unloaded plugin: ${pluginName}`);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         if (!this.isEnable) {
             return;
         }
 
         // 遍历所有已加载的插件，调用它们的事件处理方法
-        for (const [, plugin] of this.loadedPlugins) {
-            this.callPluginEventHandler(plugin, event);
+        try {
+            await Promise.allSettled(
+                Array.from(this.loadedPlugins.values()).map((plugin) =>
+                    this.callPluginEventHandler(plugin, event)
+                )
+            );
+        } catch (error) {
+            this.logger.logError('[Plugin Adapter] Error handling event:', error);
         }
     }
 

src/onebot/network/plugin.ts

@@ -251,7 +251,7 @@ export class OB11PluginAdapter extends IOB11NetworkAdapter<PluginConfig> {
         this.logger.log(`[Plugin Adapter] Unloaded plugin: ${pluginName}`);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         if (!this.isEnable) {
             return;
         }

src/onebot/network/websocket-client.ts

@@ -19,7 +19,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         super(name, config, core, obContext, actions);
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         if (this.connection && this.connection.readyState === WebSocket.OPEN) {
             this.connection.send(JSON.stringify(event));
         }
@@ -62,10 +62,15 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         }
     }
 
-    private checkStateAndReply<T>(data: T) {
-        if (this.connection && this.connection.readyState === WebSocket.OPEN) {
-            this.connection.send(JSON.stringify(data));
-        }
+    private async checkStateAndReply<T>(data: T) {
+        return new Promise<void>((resolve, reject) => {
+            if (this.connection && this.connection.readyState === WebSocket.OPEN) {
+                this.connection.send(JSON.stringify(data));
+                resolve();
+            } else {
+                reject(new Error('WebSocket is not open'));
+            }
+        });
     }
 
     private async tryConnect() {
@@ -92,7 +97,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
             });
             this.connection.on('open', () => {
                 try {
-                    this.connectEvent(this.core);
+                    this.connectEvent(this.core).catch(e => this.logger.logError('[OneBot] [WebSocket Client] 发送连接生命周期失败', e));
                 } catch (e) {
                     this.logger.logError('[OneBot] [WebSocket Client] 发送连接生命周期失败', e);
                 }
@@ -123,9 +128,9 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         }
     }
 
-    connectEvent(core: NapCatCore) {
+    async connectEvent(core: NapCatCore) {
         try {
-            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT));
+            await this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT));
         } catch (e) {
             this.logger.logError('[OneBot] [WebSocket Client] 发送生命周期失败', e);
         }
@@ -140,7 +145,7 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
             echo = receiveData.echo;
             this.logger.logDebug('[OneBot] [WebSocket Client] 收到正向Websocket消息', receiveData);
         } catch {
-            this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo));
+            await this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo));
             return;
         }
         receiveData.params = (receiveData?.params) ? receiveData.params : {};// 兼容类型验证
@@ -148,11 +153,15 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
         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));
+            await this.checkStateAndReply<unknown>(OB11Response.error('不支持的Api ' + receiveData.action, 1404, echo));
             return;
         }
-        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config);
-        this.checkStateAndReply<unknown>({ ...retdata });
+        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config, {
+            send: async (data: object) => {
+                await this.checkStateAndReply<unknown>({ ...OB11Response.ok(data, echo ?? '', true) });
+            }
+        });
+        await this.checkStateAndReply<unknown>({ ...retdata });
     }
     async reload(newConfig: WebsocketClientConfig) {
         const wasEnabled = this.isEnable;

src/onebot/network/websocket-server.ts

@@ -83,17 +83,25 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
     }
     connectEvent(core: NapCatCore, wsClient: WebSocket) {
         try {
-            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT), wsClient);
+            this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT), wsClient).catch(e => this.logger.logError('[OneBot] [WebSocket Server] 发送生命周期失败', e));
         } catch (e) {
             this.logger.logError('[OneBot] [WebSocket Server] 发送生命周期失败', e);
         }
     }
 
-    onEvent<T extends OB11EmitEventContent>(event: T) {
+    async onEvent<T extends OB11EmitEventContent>(event: T) {
         this.wsClientsMutex.runExclusive(async () => {
-            this.wsClientWithEvent.forEach((wsClient) => {
-                wsClient.send(JSON.stringify(event));
+            let promises = this.wsClientWithEvent.map((wsClient) => {
+                return new Promise<void>((resolve, reject) => {
+                    if (wsClient.readyState === WebSocket.OPEN) {
+                        wsClient.send(JSON.stringify(event));
+                        resolve();
+                    } else {
+                        reject(new Error('WebSocket is not open'));
+                    }
+                });
             });
+            await Promise.allSettled(promises);
         });
     }
 
@@ -160,10 +168,15 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
         return false;
     }
 
-    private checkStateAndReply<T>(data: T, wsClient: WebSocket) {
-        if (wsClient.readyState === WebSocket.OPEN) {
-            wsClient.send(JSON.stringify(data));
-        }
+    private async checkStateAndReply<T>(data: T, wsClient: WebSocket) {
+        return await new Promise<void>((resolve, reject) => {
+            if (wsClient.readyState === WebSocket.OPEN) {
+                wsClient.send(JSON.stringify(data));
+                resolve();
+            } else {
+                reject(new Error('WebSocket is not open'));
+            }
+        });
     }
 
     private async handleMessage(wsClient: WebSocket, message: RawData) {
@@ -175,7 +188,7 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
             echo = receiveData.echo;
             //this.logger.logDebug('收到正向Websocket消息', receiveData);
         } catch {
-            this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo), wsClient);
+            await this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo), wsClient);
             return;
         }
         receiveData.params = (receiveData?.params) ? receiveData.params : {};//兼容类型验证 不然类型校验爆炸
@@ -183,11 +196,15 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
         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);
+            await this.checkStateAndReply<unknown>(OB11Response.error('不支持的API ' + receiveData.action, 1404, echo), wsClient);
             return;
         }
-        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config);
-        this.checkStateAndReply<unknown>({ ...retdata }, wsClient);
+        const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config, {
+            send: async (data: object) => {
+                await this.checkStateAndReply<unknown>({ ...OB11Response.ok(data, echo ?? '', true) }, wsClient);
+            }
+        });
+        await this.checkStateAndReply<unknown>({ ...retdata }, wsClient);
     }
 
     async reload(newConfig: WebsocketServerConfig) {

src/onebot/types/message.ts

@@ -46,6 +46,7 @@ export interface OB11Return<DataType> {
     message: string;
     echo?: unknown; // ws调用api才有此字段
     wording?: string;  // go-cqhttp字段，错误信息
+    stream?: 'stream-action' | 'normal-action' ; // 流式返回标记
 }
 
 // 消息数据类型枚举

src/pty/windowsPtyAgent.ts

@@ -67,11 +67,11 @@ export class WindowsPtyAgent {
         }
         if (this._useConpty) {
             if (!conptyNative) {
-                conptyNative = require_dlopen('./pty/' + process.platform + '.' + process.arch + '/conpty.node');
+                conptyNative = require_dlopen('./native/pty/' + process.platform + '.' + process.arch + '/conpty.node');
             }
         } else {
             if (!winptyNative) {
-                winptyNative = require_dlopen('./pty/' + process.platform + '.' + process.arch + '/pty.node');
+                winptyNative = require_dlopen('./native/pty/' + process.platform + '.' + process.arch + '/pty.node');
             }
         }
         this._ptyNative = this._useConpty ? conptyNative : winptyNative;
@@ -203,7 +203,13 @@ export class WindowsPtyAgent {
     }
 
     private _getWindowsBuildNumber(): number {
-        const osVersion = (/(\d+)\.(\d+)\.(\d+)/g).exec(os.release());
+        const release = os.release();
+        // Limit input length to prevent potential DoS attacks
+        if (release.length > 50) {
+            return 0;
+        }
+        // Use non-global regex with more specific pattern to prevent backtracking
+        const osVersion = /^(\d{1,5})\.(\d{1,5})\.(\d{1,10})/.exec(release);
         let buildNumber: number = 0;
         if (osVersion && osVersion.length === 4) {
             buildNumber = parseInt(osVersion[3]!);