release: v3.1.6

update: bump express version to 5.0.0 (Why use beta.2?)
feat: allow pass string user_id in handleForwardedNodesPacket
2025-07-19 12:03:37 +00:00 · 2024-10-25 17:44:30 +08:00 · 2024-10-25 09:59:02 +08:00 · 2024-10-25 09:17:16 +08:00 · 2024-10-25 08:59:56 +08:00 · 2024-10-25 08:54:18 +08:00
63 changed files with 2175 additions and 598 deletions
--- a/README.md
+++ b/README.md
@@ -1,5 +1,7 @@
 <div align="center">
-  <img src="https://socialify.git.ci/NapNeko/NapCatQQ/image?font=Jost&logo=https%3A%2F%2Fnapneko.github.io%2Fassets%2Flogo.png&name=1&owner=1&pattern=Diagonal%20Stripes&stargazers=1&theme=Auto" alt="NapCatQQ" width="640" height="320" />
+  
+  ![Logo](https://socialify.git.ci/NapNeko/NapCatQQ/image?font=Jost&logo=https%3A%2F%2Fnapneko.github.io%2Fassets%2Flogo.png&name=1&owner=1&pattern=Diagonal%20Stripes&stargazers=1&theme=Auto)
+  
 </div>

 ---
--- a/launcher/qqnt.json
+++ b/launcher/qqnt.json
@@ -23,4 +23,4 @@
  "isByteCodeShell": true,
  "platform": "win32",
  "eleArch": "x64"
-}
+}
--- a/manifest.json
+++ b/manifest.json
@@ -4,7 +4,7 @@
  "name": "NapCatQQ",
  "slug": "NapCat.Framework",
  "description": "高性能的 OneBot 11 协议实现",
-  "version": "3.0.1",
+  "version": "3.1.6",
  "icon": "./logo.png",
  "authors": [
    {
--- a/package.json
+++ b/package.json
@@ -2,7 +2,7 @@
  "name": "napcat",
  "private": true,
  "type": "module",
-  "version": "3.0.1",
+  "version": "3.1.6",
  "scripts": {
    "build:framework": "vite build --mode framework",
    "build:shell": "vite build --mode shell",
@@ -13,6 +13,7 @@
  "devDependencies": {
    "@babel/preset-typescript": "^7.24.7",
    "@log4js-node/log4js-api": "^1.0.2",
+    "@protobuf-ts/runtime": "^2.9.4",
    "@rollup/plugin-node-resolve": "^15.2.3",
    "@rollup/plugin-typescript": "^11.1.6",
    "@types/cors": "^2.8.17",
@@ -23,30 +24,29 @@
    "@types/ws": "^8.5.12",
    "@typescript-eslint/eslint-plugin": "^8.3.0",
    "@typescript-eslint/parser": "^8.3.0",
+    "ajv": "^8.13.0",
+    "async-mutex": "^0.5.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "cors": "^2.8.5",
    "eslint": "^8.57.0",
    "eslint-import-resolver-typescript": "^3.6.1",
    "eslint-plugin-import": "^2.29.1",
+    "fast-xml-parser": "^4.3.6",
+    "file-type": "^19.0.0",
+    "image-size": "^1.1.1",
+    "json-schema-to-ts": "^3.1.1",
    "typescript": "^5.3.3",
    "vite": "^5.2.6",
    "vite-plugin-cp": "^4.0.8",
-    "vite-tsconfig-paths": "^4.3.2",
-    "@protobuf-ts/runtime": "^2.9.4",
-    "ajv": "^8.13.0",
-    "fast-xml-parser": "^4.3.6",
-    "chalk": "^5.3.0",
-    "commander": "^12.1.0",
-    "async-mutex": "^0.5.0",
-    "file-type": "^19.0.0",
-    "json-schema-to-ts": "^3.1.0",
-    "image-size": "^1.1.1",
-    "cors": "^2.8.5"
+    "vite-tsconfig-paths": "^4.3.2"
  },
  "dependencies": {
-    "qrcode-terminal": "^0.12.0",
+    "express": "^5.0.0",
    "fluent-ffmpeg": "^2.1.2",
-    "express": "^5.0.0-beta.2",
    "log4js": "^6.9.1",
+    "qrcode-terminal": "^0.12.0",
    "silk-wasm": "^3.6.1",
    "ws": "^8.18.0"
  }
-}
+}
--- a/src/common/forward-msg-builder.ts
+++ b/src/common/forward-msg-builder.ts
@@ -0,0 +1,118 @@
+import { PacketMsg } from "@/core/packet/msg/message";
+import * as crypto from "node:crypto";
+
+interface ForwardMsgJson {
+    app: string
+    config: ForwardMsgJsonConfig,
+    desc: string,
+    extra: ForwardMsgJsonExtra,
+    meta: ForwardMsgJsonMeta,
+    prompt: string,
+    ver: string,
+    view: string
+}
+
+interface ForwardMsgJsonConfig {
+    autosize: number,
+    forward: number,
+    round: number,
+    type: string,
+    width: number
+}
+
+interface ForwardMsgJsonExtra {
+    filename: string,
+    tsum: number,
+}
+
+interface ForwardMsgJsonMeta {
+    detail: ForwardMsgJsonMetaDetail
+}
+
+interface ForwardMsgJsonMetaDetail {
+    news: {
+        text: string
+    }[],
+    resid: string,
+    source: string,
+    summary: string,
+    uniseq: string
+}
+
+interface ForwardAdaptMsg {
+    senderName?: string;
+    isGroupMsg?: boolean;
+    msg?: ForwardAdaptMsgElement[];
+}
+
+interface ForwardAdaptMsgElement {
+    preview?: string;
+}
+
+export class ForwardMsgBuilder {
+    private static build(resId: string, msg: ForwardAdaptMsg[], source?: string, news?: ForwardMsgJsonMetaDetail["news"], summary?: string, prompt?: string): ForwardMsgJson {
+        const id = crypto.randomUUID();
+        const isGroupMsg = msg.some(m => m.isGroupMsg);
+        if (!source) {
+            source = isGroupMsg ? "群聊的聊天记录" :
+            msg.length
+                ? Array.from(new Set(msg.map(m => m.senderName)))
+                    .join('和') + '的聊天记录'
+                : '聊天记录';
+        }
+        if (!news) {
+            news = msg.length === 0 ? [{
+                text: "Nya~ This message is send from NapCat.Packet!",
+            }] : msg.map(m => ({
+                text: `${m.senderName}: ${m.msg?.map(msg => msg.preview).join('')}`,
+            }));
+        }
+        if (!summary) {
+            summary = `查看${msg.length}条转发消息`;
+        }
+        if (!prompt) {
+            prompt = "[聊天记录]";
+        }
+        return {
+            app: "com.tencent.multimsg",
+            config: {
+                autosize: 1,
+                forward: 1,
+                round: 1,
+                type: "normal",
+                width: 300
+            },
+            desc: prompt,
+            extra: {
+                filename: id,
+                tsum: msg.length,
+            },
+            meta: {
+                detail: {
+                    news,
+                    resid: resId,
+                    source,
+                    summary,
+                    uniseq: id,
+                }
+            },
+            prompt,
+            ver: "0.0.0.5",
+            view: "contact",
+        };
+    }
+
+    static fromResId(resId: string): ForwardMsgJson {
+        return this.build(resId, []);
+    }
+
+    static fromPacketMsg(resId: string, packetMsg: PacketMsg[], source?: string, news?: ForwardMsgJsonMetaDetail["news"], summary?: string, prompt?: string): ForwardMsgJson {
+        return this.build(resId, packetMsg.map(msg => ({
+            senderName: msg.senderName,
+            isGroupMsg: msg.groupId !== undefined,
+            msg: msg.msg.map(m => ({
+                preview: m.valid? m.toPreview() : "[该消息类型暂不支持查看]",
+            }))
+        })), source, news, summary, prompt);
+    }
+}
--- a/src/common/version.ts
+++ b/src/common/version.ts
@@ -1 +1 @@
-export const napCatVersion = '3.0.1';
+export const napCatVersion = '3.1.6';
--- a/src/core/apis/file.ts
+++ b/src/core/apis/file.ts
@@ -30,7 +30,7 @@ export class NTQQFileApi {
    context: InstanceContext;
    core: NapCatCore;
    rkeyManager: RkeyManager;
-    packetRkey: Array<{ rkey: string; time: number; type: number; }> | undefined;
+    packetRkey: Array<{ rkey: string; time: number; type: number; ttl: bigint }> | undefined;

    constructor(context: InstanceContext, core: NapCatCore) {
        this.context = context;
@@ -378,10 +378,12 @@ export class NTQQFileApi {
            };
            try {
                if (this.core.apis.PacketApi.available) {
-                    if ((!this.packetRkey || this.packetRkey[0].time > Date.now() / 1000)) {
+                    let rkey_expired_private = !this.packetRkey || this.packetRkey[0].time + Number(this.packetRkey[0].ttl) < Date.now() / 1000;
+                    let rkey_expired_group = !this.packetRkey || this.packetRkey[0].time + Number(this.packetRkey[0].ttl) < Date.now() / 1000;
+                    if (rkey_expired_private || rkey_expired_group) {
                        this.packetRkey = await this.core.apis.PacketApi.sendRkeyPacket();
                    }
-                    if (this.packetRkey.length > 0) {
+                    if (this.packetRkey && this.packetRkey.length > 0) {
                        rkeyData.group_rkey = this.packetRkey[1].rkey.slice(6);
                        rkeyData.private_rkey = this.packetRkey[0].rkey.slice(6);
                        rkeyData.online_rkey = true;
--- a/src/core/apis/friend.ts
+++ b/src/core/apis/friend.ts
@@ -11,7 +11,7 @@ export class NTQQFriendApi {
        this.core = core;
    }
    async setBuddyRemark(uid: string, remark: string) {
-        return this.context.session.getBuddyService().setBuddyRemark(uid, remark);
+        return this.context.session.getBuddyService().setBuddyRemark({ uid, remark });
    }
    async getBuddyV2SimpleInfoMap(refresh = false) {
        const buddyService = this.context.session.getBuddyService();
--- a/src/core/apis/group.ts
+++ b/src/core/apis/group.ts
@@ -318,7 +318,7 @@ export class NTQQGroupApi {

    async getGroupMembersV2(groupQQ: string, num = 3000): Promise<Map<string, GroupMember>> {
        const sceneId = this.context.session.getGroupService().createMemberListScene(groupQQ, 'groupMemberList_MainWindow');
-        let once = this.core.eventWrapper.registerListen('NodeIKernelGroupListener/onMemberListChange', 1, 2000, (params) => params.sceneId === sceneId)
+        const once = this.core.eventWrapper.registerListen('NodeIKernelGroupListener/onMemberListChange', 1, 2000, (params) => params.sceneId === sceneId)
            .catch();
        const result = await this.context.session.getGroupService().getNextMemberList(sceneId!, undefined, num);
        if (result.errCode !== 0) {
--- a/src/core/apis/packet.ts
+++ b/src/core/apis/packet.ts
@@ -1,18 +1,24 @@
 import * as os from 'os';
-import {ChatType, InstanceContext, NapCatCore} from '..';
+import { ChatType, InstanceContext, NapCatCore } from '..';
 import offset from '@/core/external/offset.json';
-import {PacketClient, RecvPacketData} from '@/core/packet/client';
-import {PacketSession} from "@/core/packet/session";
-import {PacketHexStr} from "@/core/packet/packer";
-import {NapProtoMsg} from '@/core/packet/proto/NapProto';
-import {OidbSvcTrpcTcp0X9067_202_Rsp_Body} from '@/core/packet/proto/oidb/Oidb.0x9067_202';
-import {OidbSvcTrpcTcpBase, OidbSvcTrpcTcpBaseRsp} from '@/core/packet/proto/oidb/OidbBase';
-import {OidbSvcTrpcTcp0XFE1_2RSP} from '@/core/packet/proto/oidb/Oidb.0XFE1_2';
-import {LogWrapper} from "@/common/log";
-import {SendLongMsgResp} from "@/core/packet/proto/message/action";
-import {PacketMsg} from "@/core/packet/msg/message";
-import {OidbSvcTrpcTcp0x6D6Response} from "@/core/packet/proto/oidb/Oidb.0x6D6";
-import {PacketMsgPicElement} from "@/core/packet/msg/element";
+import { PacketClient, RecvPacketData } from '@/core/packet/client';
+import { PacketSession } from "@/core/packet/session";
+import {OidbPacket, PacketHexStr} from "@/core/packet/packer";
+import { NapProtoMsg } from '@/core/packet/proto/NapProto';
+import { OidbSvcTrpcTcp0X9067_202_Rsp_Body } from '@/core/packet/proto/oidb/Oidb.0x9067_202';
+import { OidbSvcTrpcTcpBase, OidbSvcTrpcTcpBaseRsp } from '@/core/packet/proto/oidb/OidbBase';
+import { OidbSvcTrpcTcp0XFE1_2RSP } from '@/core/packet/proto/oidb/Oidb.0XFE1_2';
+import { LogWrapper } from "@/common/log";
+import { SendLongMsgResp } from "@/core/packet/proto/message/action";
+import { PacketMsg } from "@/core/packet/msg/message";
+import { OidbSvcTrpcTcp0x6D6Response } from "@/core/packet/proto/oidb/Oidb.0x6D6";
+import {
+    PacketMsgFileElement,
+    PacketMsgPicElement,
+    PacketMsgPttElement,
+    PacketMsgVideoElement
+} from "@/core/packet/msg/element";
+

 interface OffsetType {
    [key: string]: {
@@ -26,7 +32,7 @@ const typedOffset: OffsetType = offset;
 export class NTQQPacketApi {
    context: InstanceContext;
    core: NapCatCore;
-    logger: LogWrapper
+    logger: LogWrapper;
    serverUrl: string | undefined;
    qqVersion: string | undefined;
    packetSession: PacketSession | undefined;
@@ -59,8 +65,12 @@ export class NTQQPacketApi {
        if (!table) return false;
        const url = 'ws://' + this.serverUrl + '/ws';
        this.packetSession = new PacketSession(this.core.context.logger, new PacketClient(url, this.core));
-        await this.packetSession.client.connect();
-        await this.packetSession.client.init(process.pid, table.recv, table.send);
+        const cb = () => {
+            if (this.packetSession && this.packetSession.client) {
+                this.packetSession.client.init(process.pid, table.recv, table.send).then().catch(this.logger.logError.bind(this.logger));
+            }
+        };
+        await this.packetSession.client.connect(cb);
        return true;
    }

@@ -68,25 +78,32 @@ export class NTQQPacketApi {
        return this.packetSession!.client.sendPacket(cmd, data, rsp);
    }

-    async sendPokePacket(group: number, peer: number) {
-        const data = this.packetSession?.packer.packPokePacket(group, peer);
-        await this.sendPacket('OidbSvcTrpcTcp.0xed3_1', data!, false);
+    async sendOidbPacket(pkt: OidbPacket, rsp = false): Promise<RecvPacketData> {
+        return this.sendPacket(pkt.cmd, pkt.data, rsp);
+    }
+
+    async sendPokePacket(peer: number, group?: number) {
+        const data = this.packetSession?.packer.packPokePacket(peer, group);
+        await this.sendOidbPacket(data!, false);
    }

    async sendRkeyPacket() {
        const packet = this.packetSession?.packer.packRkeyPacket();
-        const ret = await this.sendPacket('OidbSvcTrpcTcp.0x9067_202', packet!, true);
+        const ret = await this.sendOidbPacket(packet!, true);
        if (!ret?.hex_data) return [];
        const body = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(Buffer.from(ret.hex_data, 'hex')).body;
        const retData = new NapProtoMsg(OidbSvcTrpcTcp0X9067_202_Rsp_Body).decode(body);
        return retData.data.rkeyList;
    }
-
+    async sendGroupSignPacket(groupCode: string) {
+        const packet = this.packetSession?.packer.packGroupSignReq(this.core.selfInfo.uin, groupCode);
+        await this.sendOidbPacket(packet!, true);
+    }
    async sendStatusPacket(uin: number): Promise<{ status: number; ext_status: number; } | undefined> {
        let status = 0;
        try {
            const packet = this.packetSession?.packer.packStatusPacket(uin);
-            const ret = await this.sendPacket('OidbSvcTrpcTcp.0xfe1_2', packet!, true);
+            const ret = await this.sendOidbPacket( packet!, true);
            const data = Buffer.from(ret.hex_data, 'hex');
            const ext = new NapProtoMsg(OidbSvcTrpcTcp0XFE1_2RSP).decode(new NapProtoMsg(OidbSvcTrpcTcpBase).decode(data).body).data.status.value;
            // ext & 0xff00 + ext >> 16 & 0xff
@@ -103,22 +120,47 @@ export class NTQQPacketApi {

    async sendSetSpecialTittlePacket(groupCode: string, uid: string, tittle: string) {
        const data = this.packetSession?.packer.packSetSpecialTittlePacket(groupCode, uid, tittle);
-        await this.sendPacket('OidbSvcTrpcTcp.0x8fc_2', data!, true);
+        await this.sendOidbPacket(data!, true);
    }

-    private async uploadResources(msg: PacketMsg[], groupUin: number = 0){
-        const reqList = []
-        for (const m of msg){
-            for (const e of m.msg){
-                if (e instanceof PacketMsgPicElement){
+    // TODO: can simplify this
+    async uploadResources(msg: PacketMsg[], groupUin: number = 0) {
+        const reqList = [];
+        for (const m of msg) {
+            for (const e of m.msg) {
+                if (e instanceof PacketMsgPicElement) {
                    reqList.push(this.packetSession?.highwaySession.uploadImage({
                        chatType: groupUin ? ChatType.KCHATTYPEGROUP : ChatType.KCHATTYPEC2C,
-                        peerUid: String(groupUin) ? String(groupUin) : this.core.selfInfo.uid
+                        peerUid: groupUin ? String(groupUin) : this.core.selfInfo.uid
+                    }, e));
+                }
+                if (e instanceof PacketMsgVideoElement) {
+                    reqList.push(this.packetSession?.highwaySession.uploadVideo({
+                        chatType: groupUin ? ChatType.KCHATTYPEGROUP : ChatType.KCHATTYPEC2C,
+                        peerUid: groupUin ? String(groupUin) : this.core.selfInfo.uid
+                    }, e));
+                }
+                if (e instanceof PacketMsgPttElement) {
+                    reqList.push(this.packetSession?.highwaySession.uploadPtt({
+                        chatType: groupUin ? ChatType.KCHATTYPEGROUP : ChatType.KCHATTYPEC2C,
+                        peerUid: groupUin ? String(groupUin) : this.core.selfInfo.uid
+                    }, e));
+                }
+                if (e instanceof PacketMsgFileElement){
+                    reqList.push(this.packetSession?.highwaySession.uploadFile({
+                        chatType: groupUin ? ChatType.KCHATTYPEGROUP : ChatType.KCHATTYPEC2C,
+                        peerUid: groupUin ? String(groupUin) : this.core.selfInfo.uid
                    }, e));
                }
            }
        }
-        return Promise.all(reqList);
+        const res = await Promise.allSettled(reqList);
+        this.logger.log(`上传资源${res.length}个， 失败${res.filter(r => r.status === 'rejected').length}个`);
+        res.forEach((result, index) => {
+            if (result.status === 'rejected') {
+                this.logger.logError(`第${index + 1}个失败：${result.reason}`);
+            }
+        });
    }

    async sendUploadForwardMsg(msg: PacketMsg[], groupUin: number = 0) {
@@ -132,12 +174,12 @@ export class NTQQPacketApi {

    async sendGroupFileDownloadReq(groupUin: number, fileUUID: string) {
        const data = this.packetSession?.packer.packGroupFileDownloadReq(groupUin, fileUUID);
-        const ret = await this.sendPacket('OidbSvcTrpcTcp.0x6d6_2', data!, true);
+        const ret = await this.sendOidbPacket(data!, true);
        const body = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(Buffer.from(ret.hex_data, 'hex')).body;
        const resp = new NapProtoMsg(OidbSvcTrpcTcp0x6D6Response).decode(body);
-        if (resp.download.retCode !== 0){
+        if (resp.download.retCode !== 0) {
            throw new Error(`sendGroupFileDownloadReq error: ${resp.download.clientWording}`);
        }
-        return `https://${resp.download.downloadDns}/ftn_handler/${Buffer.from(resp.download.downloadUrl).toString('hex')}/?fname=`
+        return `https://${resp.download.downloadDns}/ftn_handler/${Buffer.from(resp.download.downloadUrl).toString('hex')}/?fname=`;
    }
 }
--- a/src/core/apis/webapi.ts
+++ b/src/core/apis/webapi.ts
@@ -338,4 +338,12 @@ export class NTQQWebApi {
        }
        return (hash & 0x7FFFFFFF).toString();
    }
+    public getBknFromSKey(sKey: string) {
+        let hash = 5381;
+        for (let i = 0; i < sKey.length; i++) {
+            const code = sKey.charCodeAt(i);
+            hash = hash + (hash << 5) + code;
+        }
+        return (hash & 0x7FFFFFFF).toString();
+    }
 }
--- a/src/core/entities/msg.ts
+++ b/src/core/entities/msg.ts
@@ -517,6 +517,12 @@ export enum AtType {
    atAll = 1,
    atUser = 2
 }
+export enum MsgSourceType {
+    K_DOWN_SOURCETYPE_AIOINNER = 1,
+    K_DOWN_SOURCETYPE_BIGSCREEN = 2,
+    K_DOWN_SOURCETYPE_HISTORY = 3,
+    K_DOWN_SOURCETYPE_UNKNOWN = 0
+}

 // 来自Android分析
 export enum ChatType {
@@ -874,6 +880,8 @@ export interface RawMessage {
    /**
     * 扩展字段，与 Ob11 msg ID 有关
     */
+
+
    id?: number;

    guildId: string;
@@ -950,6 +958,8 @@ export interface RawMessage {
    records: RawMessage[];

    elements: MessageElement[];
+
+    sourceType: MsgSourceType;
 }
 export interface QueryMsgsParams {
    chatInfo: Peer;
--- a/src/core/external/appid.json
+++ b/src/core/external/appid.json
@@ -50,5 +50,13 @@
    "9.9.16-28788": {
        "appid": 537249739,
        "qua": "V1_WIN_NQ_9.9.16_28788_GW_B"
+    },
+    "9.9.16-28971":{
+        "appid": 537249775,
+        "qua": "V1_WIN_NQ_9.9.16_28971_GW_B"
+    },
+    "3.2.13-28971": {
+        "appid": 537249848,
+        "qua": "V1_LNX_NQ_3.2.13_28971_GW_B"
    }
 }
--- a/src/core/external/offset.json
+++ b/src/core/external/offset.json
@@ -18,5 +18,21 @@
    "3.2.13-28788-x64": {
        "send": "A0CEC20",
        "recv": "A0D2520"
+    },
+    "3.2.13-28788-arm64": {
+        "send": "6E91018",
+        "recv": "6E94850"
+    },
+    "9.9.16-28971-x64": {
+        "send": "38079F0",
+        "recv": "380BE24"
+    },
+    "3.2.13-28971-x64": {
+        "send": "A0CEF60",
+        "recv": "A0D2860"
+    },
+    "3.2.12-28971-arm64": {
+        "send": "6E91318",
+        "recv": "6E94B50"
    }
 }
--- a/src/core/packet/client.ts
+++ b/src/core/packet/client.ts
@@ -3,8 +3,7 @@ import { LRUCache } from "@/common/lru-cache";
 import WebSocket, { Data } from "ws";
 import crypto, { createHash } from "crypto";
 import { NapCatCore } from "@/core";
-import { PacketHexStr } from "@/core/packet/packer";
-import { sleep } from "@/common/helper";
+import { OidbPacket, PacketHexStr } from "@/core/packet/packer";

 export interface RecvPacket {
    type: string, // 仅recv
@@ -22,7 +21,7 @@ export class PacketClient {
    private websocket: WebSocket | undefined;
    private isConnected: boolean = false;
    private reconnectAttempts: number = 0;
-    private readonly maxReconnectAttempts: number = 5;//现在暂时不可配置
+    private readonly maxReconnectAttempts: number = 60;//现在暂时不可配置
    private readonly cb = new LRUCache<string, (json: RecvPacketData) => Promise<void>>(500); // trace_id-type callback
    private readonly clientUrl: string = '';
    readonly napCatCore: NapCatCore;
@@ -47,16 +46,17 @@ export class PacketClient {
        return text;
    }

-    connect(): Promise<void> {
+    connect(cb: any): Promise<void> {
        return new Promise((resolve, reject) => {
            //this.logger.log.bind(this.logger)(`[Core] [Packet Server] Attempting to connect to ${this.clientUrl}`);
            this.websocket = new WebSocket(this.clientUrl);
-            this.websocket.on('error', (err) => {}/*this.logger.logError.bind(this.logger)('[Core] [Packet Server] Error:', err.message)*/);
+            this.websocket.on('error', (err) => { }/*this.logger.logError.bind(this.logger)('[Core] [Packet Server] Error:', err.message)*/);

            this.websocket.onopen = () => {
                this.isConnected = true;
                this.reconnectAttempts = 0;
                this.logger.log.bind(this.logger)(`[Core] [Packet Server] Connected to ${this.clientUrl}`);
+                cb();
                resolve();
            };

@@ -74,17 +74,17 @@ export class PacketClient {
            this.websocket.onclose = () => {
                this.isConnected = false;
                //this.logger.logWarn.bind(this.logger)(`[Core] [Packet Server] Disconnected from ${this.clientUrl}`);
-                this.attemptReconnect();
+                this.attemptReconnect(cb);
            };
        });
    }

-    private attemptReconnect(): void {
+    private attemptReconnect(cb: any): void {
        try {
            if (this.reconnectAttempts < this.maxReconnectAttempts) {
                this.reconnectAttempts++;
                setTimeout(() => {
-                    this.connect().catch((error) => {
+                    this.connect(cb).catch((error) => {
                        this.logger.logError.bind(this.logger)(`[Core] [Packet Server] Reconnecting attempt failed,${error.message}`);
                    });
                }, 5000 * this.reconnectAttempts);
@@ -176,4 +176,8 @@ export class PacketClient {
            }).then((res) => resolve(res)).catch((e: Error) => reject(e));
        });
    }
+
+    async sendOidbPacket(pkt: OidbPacket, rsp = false): Promise<RecvPacketData> {
+        return this.sendPacket(pkt.cmd, pkt.data, rsp);
+    }
 }
--- a/src/core/packet/highway/client.ts
+++ b/src/core/packet/highway/client.ts
@@ -1,8 +1,8 @@
 import * as stream from 'node:stream';
-import {ReadStream} from "node:fs";
-import {PacketHighwaySig} from "@/core/packet/highway/session";
-import {HighwayHttpUploader, HighwayTcpUploader} from "@/core/packet/highway/uploader";
-import {LogWrapper} from "@/common/log";
+import { ReadStream } from "node:fs";
+import { PacketHighwaySig } from "@/core/packet/highway/session";
+import { HighwayHttpUploader, HighwayTcpUploader } from "@/core/packet/highway/uploader";
+import { LogWrapper } from "@/common/log";

 export interface PacketHighwayTrans {
    uin: string;
@@ -36,7 +36,7 @@ export class PacketHighwayClient {
        this.port = port;
    }

-    private buildDataUpTrans(cmd: number, data: ReadStream, fileSize: number, md5: Uint8Array, extendInfo: Uint8Array, timeout: number = 3600): PacketHighwayTrans {
+    private buildDataUpTrans(cmd: number, data: ReadStream, fileSize: number, md5: Uint8Array, extendInfo: Uint8Array, timeout: number = 1200): PacketHighwayTrans {
        return {
            uin: this.sig.uin,
            cmd: cmd,
--- a/src/core/packet/highway/session.ts
+++ b/src/core/packet/highway/session.ts
@@ -1,16 +1,24 @@
 import * as fs from "node:fs";
-import {ChatType, Peer} from "@/core";
-import {LogWrapper} from "@/common/log";
-import {PacketClient} from "@/core/packet/client";
-import {PacketPacker} from "@/core/packet/packer";
-import {NapProtoMsg} from "@/core/packet/proto/NapProto";
-import {HttpConn0x6ff_501Response} from "@/core/packet/proto/action/action";
-import {PacketHighwayClient} from "@/core/packet/highway/client";
-import {NTV2RichMediaResp} from "@/core/packet/proto/oidb/common/Ntv2.RichMediaResp";
-import {OidbSvcTrpcTcpBaseRsp} from "@/core/packet/proto/oidb/OidbBase";
-import {PacketMsgPicElement} from "@/core/packet/msg/element";
-import {NTV2RichMediaHighwayExt} from "@/core/packet/proto/highway/highway";
-import {int32ip2str, oidbIpv4s2HighwayIpv4s} from "@/core/packet/highway/utils";
+import { ChatType, Peer } from "@/core";
+import { LogWrapper } from "@/common/log";
+import { PacketClient } from "@/core/packet/client";
+import { PacketPacker } from "@/core/packet/packer";
+import { NapProtoMsg } from "@/core/packet/proto/NapProto";
+import { HttpConn0x6ff_501Response } from "@/core/packet/proto/action/action";
+import { PacketHighwayClient } from "@/core/packet/highway/client";
+import { NTV2RichMediaResp } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaResp";
+import { OidbSvcTrpcTcpBaseRsp } from "@/core/packet/proto/oidb/OidbBase";
+import {
+    PacketMsgFileElement,
+    PacketMsgPicElement,
+    PacketMsgPttElement,
+    PacketMsgVideoElement
+} from "@/core/packet/msg/element";
+import { FileUploadExt, NTV2RichMediaHighwayExt } from "@/core/packet/proto/highway/highway";
+import { int32ip2str, oidbIpv4s2HighwayIpv4s } from "@/core/packet/highway/utils";
+import { calculateSha1, calculateSha1StreamBytes, computeMd5AndLengthWithLimit } from "@/core/packet/utils/crypto/hash";
+import { OidbSvcTrpcTcp0x6D6Response } from "@/core/packet/proto/oidb/Oidb.0x6D6";
+import { OidbSvcTrpcTcp0XE37_800Response, OidbSvcTrpcTcp0XE37Response } from "@/core/packet/proto/oidb/Oidb.0XE37_800";

 export const BlockSize = 1024 * 1024;

@@ -21,6 +29,7 @@ interface HighwayServerAddr {

 export interface PacketHighwaySig {
    uin: string;
+    uid: string;
    sigSession: Uint8Array | null
    sessionKey: Uint8Array | null
    serverAddr: HighwayServerAddr[]
@@ -39,17 +48,17 @@ export class PacketHighwaySession {
        this.logger = logger;
        this.sig = {
            uin: this.packetClient.napCatCore.selfInfo.uin,
+            uid: this.packetClient.napCatCore.selfInfo.uid,
            sigSession: null,
            sessionKey: null,
            serverAddr: [],
-        }
+        };
        this.packer = packer;
        this.packetHighwayClient = new PacketHighwayClient(this.sig, this.logger);
    }

    private async checkAvailable() {
        if (!this.packetClient.available) {
-            this.logger.logError('[Highway] packetServer not available!');
            throw new Error('packetServer不可用，请参照文档 https://napneko.github.io/config/advanced 检查packetServer状态或进行配置');
        }
        if (this.sig.sigSession === null || this.sig.sessionKey === null) {
@@ -69,8 +78,8 @@ export class PacketHighwaySession {
        const rsp = new NapProtoMsg(HttpConn0x6ff_501Response).decode(
            Buffer.from(req.hex_data, 'hex')
        );
-        this.sig.sigSession = rsp.httpConn.sigSession
-        this.sig.sessionKey = rsp.httpConn.sessionKey
+        this.sig.sigSession = rsp.httpConn.sigSession;
+        this.sig.sessionKey = rsp.httpConn.sessionKey;
        for (const info of rsp.httpConn.serverInfos) {
            if (info.serviceType !== 1) continue;
            for (const addr of info.serverAddrs) {
@@ -78,7 +87,7 @@ export class PacketHighwaySession {
                this.sig.serverAddr.push({
                    ip: int32ip2str(addr.ip),
                    port: addr.port
-                })
+                });
            }
        }
    }
@@ -86,7 +95,7 @@ export class PacketHighwaySession {
    async uploadImage(peer: Peer, img: PacketMsgPicElement): Promise<void> {
        await this.checkAvailable();
        if (peer.chatType === ChatType.KCHATTYPEGROUP) {
-            await this.uploadGroupImageReq(Number(peer.peerUid), img);
+            await this.uploadGroupImageReq(+peer.peerUid, img);
        } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
            await this.uploadC2CImageReq(peer.peerUid, img);
        } else {
@@ -94,16 +103,53 @@ export class PacketHighwaySession {
        }
    }

+    async uploadVideo(peer: Peer, video: PacketMsgVideoElement): Promise<void> {
+        await this.checkAvailable();
+        if (+(video.fileSize ?? 0) > 1024 * 1024 * 100) {
+            throw new Error(`[Highway] 视频文件过大: ${(+(video.fileSize ?? 0) / (1024 * 1024)).toFixed(2)} MB > 100 MB，请使用文件上传！`);
+        }
+        if (peer.chatType === ChatType.KCHATTYPEGROUP) {
+            await this.uploadGroupVideoReq(+peer.peerUid, video);
+        } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
+            await this.uploadC2CVideoReq(peer.peerUid, video);
+        } else {
+            throw new Error(`[Highway] unsupported chatType: ${peer.chatType}`);
+        }
+    }
+
+    async uploadPtt(peer: Peer, ptt: PacketMsgPttElement): Promise<void> {
+        await this.checkAvailable();
+        if (peer.chatType === ChatType.KCHATTYPEGROUP) {
+            await this.uploadGroupPttReq(+peer.peerUid, ptt);
+        } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
+            await this.uploadC2CPttReq(peer.peerUid, ptt);
+        } else {
+            throw new Error(`[Highway] unsupported chatType: ${peer.chatType}`);
+        }
+    }
+
+    async uploadFile(peer: Peer, file: PacketMsgFileElement): Promise<void> {
+        await this.checkAvailable();
+        if (peer.chatType === ChatType.KCHATTYPEGROUP) {
+            await this.uploadGroupFileReq(+peer.peerUid, file);
+        } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
+            await this.uploadC2CFileReq(peer.peerUid, file);
+        } else {
+            throw new Error(`[Highway] unsupported chatType: ${peer.chatType}`);
+        }
+    }
+
    private async uploadGroupImageReq(groupUin: number, img: PacketMsgPicElement): Promise<void> {
+        img.sha1 = Buffer.from(await calculateSha1(img.path)).toString('hex');
        const preReq = await this.packer.packUploadGroupImgReq(groupUin, img);
-        const preRespRaw = await this.packetClient.sendPacket('OidbSvcTrpcTcp.0x11c4_100', preReq, true);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
            Buffer.from(preRespRaw.hex_data, 'hex')
        );
        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
        const ukey = preRespData.upload.uKey;
        if (ukey && ukey != "") {
-            this.logger.logDebug(`[Highway] get upload ukey: ${ukey}, need upload!`);
+            this.logger.logDebug(`[Highway] uploadGroupImageReq get upload ukey: ${ukey}, need upload!`);
            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
            const md5 = Buffer.from(index.info.fileHash, 'hex');
@@ -118,7 +164,7 @@ export class PacketHighwaySession {
                hash: {
                    fileSha1: [sha1]
                }
-            })
+            });
            await this.packetHighwayClient.upload(
                1004,
                fs.createReadStream(img.path, {highWaterMark: BlockSize}),
@@ -127,22 +173,23 @@ export class PacketHighwaySession {
                extend
            );
        } else {
-            this.logger.logDebug(`[Highway] get upload invalid ukey ${ukey}, don't need upload!`);
+            this.logger.logDebug(`[Highway] uploadGroupImageReq get upload invalid ukey ${ukey}, don't need upload!`);
        }
        img.msgInfo = preRespData.upload.msgInfo;
        // img.groupPicExt = new NapProtoMsg(CustomFace).decode(preRespData.tcpUpload.compatQMsg)
    }

    private async uploadC2CImageReq(peerUid: string, img: PacketMsgPicElement): Promise<void> {
+        img.sha1 = Buffer.from(await calculateSha1(img.path)).toString('hex');
        const preReq = await this.packer.packUploadC2CImgReq(peerUid, img);
-        const preRespRaw = await this.packetClient.sendPacket('OidbSvcTrpcTcp.0x11c5_100', preReq, true);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
            Buffer.from(preRespRaw.hex_data, 'hex')
        );
        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
        const ukey = preRespData.upload.uKey;
        if (ukey && ukey != "") {
-            this.logger.logDebug(`[Highway] get upload ukey: ${ukey}, need upload!`);
+            this.logger.logDebug(`[Highway] uploadC2CImageReq get upload ukey: ${ukey}, need upload!`);
            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
            const md5 = Buffer.from(index.info.fileHash, 'hex');
@@ -157,7 +204,7 @@ export class PacketHighwaySession {
                hash: {
                    fileSha1: [sha1]
                }
-            })
+            });
            await this.packetHighwayClient.upload(
                1003,
                fs.createReadStream(img.path, {highWaterMark: BlockSize}),
@@ -165,7 +212,359 @@ export class PacketHighwaySession {
                md5,
                extend
            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CImageReq get upload invalid ukey ${ukey}, don't need upload!`);
        }
        img.msgInfo = preRespData.upload.msgInfo;
    }
+
+    private async uploadGroupVideoReq(groupUin: number, video: PacketMsgVideoElement): Promise<void> {
+        if (!video.filePath || !video.thumbPath) throw new Error("video.filePath or video.thumbPath is empty");
+        video.fileSha1 = Buffer.from(await calculateSha1(video.filePath)).toString('hex');
+        video.thumbSha1 = Buffer.from(await calculateSha1(video.thumbPath)).toString('hex');
+        const preReq = await this.packer.packUploadGroupVideoReq(groupUin, video);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
+        const ukey = preRespData.upload.uKey;
+        if (ukey && ukey != "") {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload video ukey: ${ukey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: ukey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(preRespData.upload.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: await calculateSha1StreamBytes(video.filePath!)
+                }
+            })
+            await this.packetHighwayClient.upload(
+                1005,
+                fs.createReadStream(video.filePath!, {highWaterMark: BlockSize}),
+                +video.fileSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload invalid ukey ${ukey}, don't need upload!`);
+        }
+        const subFile = preRespData.upload.subFileInfos[0];
+        if (subFile.uKey && subFile.uKey != "") {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload video thumb ukey: ${subFile.uKey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[1].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: subFile.uKey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(subFile.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: [sha1]
+                }
+            });
+            await this.packetHighwayClient.upload(
+                1006,
+                fs.createReadStream(video.thumbPath!, {highWaterMark: BlockSize}),
+                +video.thumbSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadGroupVideoReq get upload invalid thumb ukey ${subFile.uKey}, don't need upload!`);
+        }
+        video.msgInfo = preRespData.upload.msgInfo;
+    }
+
+    private async uploadC2CVideoReq(peerUid: string, video: PacketMsgVideoElement): Promise<void> {
+        if (!video.filePath || !video.thumbPath) throw new Error("video.filePath or video.thumbPath is empty");
+        video.fileSha1 = Buffer.from(await calculateSha1(video.filePath)).toString('hex');
+        video.thumbSha1 = Buffer.from(await calculateSha1(video.thumbPath)).toString('hex');
+        const preReq = await this.packer.packUploadC2CVideoReq(peerUid, video);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
+        const ukey = preRespData.upload.uKey;
+        if (ukey && ukey != "") {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload video ukey: ${ukey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: ukey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(preRespData.upload.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: await calculateSha1StreamBytes(video.filePath!)
+                }
+            })
+            await this.packetHighwayClient.upload(
+                1001,
+                fs.createReadStream(video.filePath!, {highWaterMark: BlockSize}),
+                +video.fileSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload invalid ukey ${ukey}, don't need upload!`);
+        }
+        const subFile = preRespData.upload.subFileInfos[0];
+        if (subFile.uKey && subFile.uKey != "") {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload video thumb ukey: ${subFile.uKey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[1].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: subFile.uKey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(subFile.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: [sha1]
+                }
+            });
+            await this.packetHighwayClient.upload(
+                1002,
+                fs.createReadStream(video.thumbPath!, {highWaterMark: BlockSize}),
+                +video.thumbSize!,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CVideoReq get upload invalid thumb ukey ${subFile.uKey}, don't need upload!`);
+        }
+        video.msgInfo = preRespData.upload.msgInfo;
+    }
+
+    private async uploadGroupPttReq(groupUin: number, ptt: PacketMsgPttElement): Promise<void> {
+        ptt.fileSha1 = Buffer.from(await calculateSha1(ptt.filePath)).toString('hex');
+        const preReq = await this.packer.packUploadGroupPttReq(groupUin, ptt);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
+        const ukey = preRespData.upload.uKey;
+        if (ukey && ukey != "") {
+            this.logger.logDebug(`[Highway] uploadGroupPttReq get upload ptt ukey: ${ukey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: ukey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(preRespData.upload.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: [sha1]
+                }
+            })
+            await this.packetHighwayClient.upload(
+                1008,
+                fs.createReadStream(ptt.filePath, {highWaterMark: BlockSize}),
+                ptt.fileSize,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadGroupPttReq get upload invalid ukey ${ukey}, don't need upload!`);
+        }
+        ptt.msgInfo = preRespData.upload.msgInfo;
+    }
+
+    private async uploadC2CPttReq(peerUid: string, ptt: PacketMsgPttElement): Promise<void> {
+        ptt.fileSha1 = Buffer.from(await calculateSha1(ptt.filePath)).toString('hex');
+        const preReq = await this.packer.packUploadC2CPttReq(peerUid, ptt);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(NTV2RichMediaResp).decode(preResp.body);
+        const ukey = preRespData.upload.uKey;
+        if (ukey && ukey != "") {
+            this.logger.logDebug(`[Highway] uploadC2CPttReq get upload ptt ukey: ${ukey}, need upload!`);
+            const index = preRespData.upload.msgInfo.msgInfoBody[0].index;
+            const md5 = Buffer.from(index.info.fileHash, 'hex');
+            const sha1 = Buffer.from(index.info.fileSha1, 'hex');
+            const extend = new NapProtoMsg(NTV2RichMediaHighwayExt).encode({
+                fileUuid: index.fileUuid,
+                uKey: ukey,
+                network: {
+                    ipv4S: oidbIpv4s2HighwayIpv4s(preRespData.upload.ipv4S)
+                },
+                msgInfoBody: preRespData.upload.msgInfo.msgInfoBody,
+                blockSize: BlockSize,
+                hash: {
+                    fileSha1: [sha1]
+                }
+            })
+            await this.packetHighwayClient.upload(
+                1007,
+                fs.createReadStream(ptt.filePath, {highWaterMark: BlockSize}),
+                ptt.fileSize,
+                md5,
+                extend
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadC2CPttReq get upload invalid ukey ${ukey}, don't need upload!`);
+        }
+        ptt.msgInfo = preRespData.upload.msgInfo;
+    }
+
+    private async uploadGroupFileReq(groupUin: number, file: PacketMsgFileElement): Promise<void> {
+        file.isGroupFile = true;
+        file.fileMd5 = await computeMd5AndLengthWithLimit(file.filePath);
+        file.fileSha1 = await calculateSha1(file.filePath);
+        const preReq = await this.packer.packUploadGroupFileReq(groupUin, file);
+        const preRespRaw = await this.packetClient.sendOidbPacket(preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(OidbSvcTrpcTcp0x6D6Response).decode(preResp.body);
+        if (!preRespData?.upload?.boolFileExist) {
+            this.logger.logDebug(`[Highway] uploadGroupFileReq file not exist, need upload!`);
+            const ext = new NapProtoMsg(FileUploadExt).encode({
+                unknown1: 100,
+                unknown2: 1,
+                entry: {
+                    busiBuff: {
+                        senderUin: BigInt(this.sig.uin),
+                        receiverUin: BigInt(groupUin),
+                        groupCode: BigInt(groupUin),
+                    },
+                    fileEntry: {
+                        fileSize: BigInt(file.fileSize),
+                        md5: file.fileMd5,
+                        md5S2: file.fileMd5,
+                        checkKey: preRespData.upload.checkKey,
+                        fileId: preRespData.upload.fileId,
+                        uploadKey: preRespData.upload.fileKey,
+                    },
+                    clientInfo: {
+                        clientType: 3,
+                        appId: "100",
+                        terminalType: 3,
+                        clientVer: "1.1.1",
+                        unknown: 4
+                    },
+                    fileNameInfo: {
+                        fileName: file.fileName
+                    },
+                    host: {
+                        hosts: [
+                            {
+                                url: {
+                                    host: preRespData.upload.uploadIp,
+                                    unknown: 1,
+                                },
+                                port: preRespData.upload.uploadPort,
+                            }
+                        ]
+                    }
+                },
+                unknown200: 0,
+            })
+            await this.packetHighwayClient.upload(
+                71,
+                fs.createReadStream(file.filePath, {highWaterMark: BlockSize}),
+                file.fileSize,
+                file.fileMd5,
+                ext
+            );
+        } else {
+            this.logger.logDebug(`[Highway] uploadGroupFileReq file exist, don't need upload!`);
+        }
+        file.fileUuid = preRespData.upload.fileId;
+    }
+
+    private async uploadC2CFileReq(peerUid: string, file: PacketMsgFileElement): Promise<void> {
+        file.isGroupFile = false;
+        file.fileMd5 = await computeMd5AndLengthWithLimit(file.filePath);
+        file.fileSha1 = await calculateSha1(file.filePath);
+        const preReq = await this.packer.packUploadC2CFileReq(this.sig.uid, peerUid, file);
+        const preRespRaw = await this.packetClient.sendOidbPacket( preReq, true);
+        const preResp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(
+            Buffer.from(preRespRaw.hex_data, 'hex')
+        );
+        const preRespData = new NapProtoMsg(OidbSvcTrpcTcp0XE37Response).decode(preResp.body);
+        if (!preRespData.upload?.boolFileExist) {
+            this.logger.logDebug(`[Highway] uploadC2CFileReq file not exist, need upload!`);
+            const ext = new NapProtoMsg(FileUploadExt).encode({
+                unknown1: 100,
+                unknown2: 1,
+                entry: {
+                    busiBuff: {
+                        senderUin: BigInt(this.sig.uin),
+                    },
+                    fileEntry: {
+                        fileSize: BigInt(file.fileSize),
+                        md5: file.fileMd5,
+                        md5S2: file.fileMd5,
+                        checkKey: file.fileSha1,
+                        fileId: preRespData.upload?.uuid,
+                        uploadKey: preRespData.upload?.mediaPlatformUploadKey,
+                    },
+                    clientInfo: {
+                        clientType: 3,
+                        appId: "100",
+                        terminalType: 3,
+                        clientVer: "1.1.1",
+                        unknown: 4
+                    },
+                    fileNameInfo: {
+                        fileName: file.fileName
+                    },
+                    host: {
+                        hosts: [
+                            {
+                                url: {
+                                    host: preRespData.upload?.uploadIp,
+                                    unknown: 1,
+                                },
+                                port: preRespData.upload?.uploadPort,
+                            }
+                        ]
+                    }
+                },
+                unknown200: 1,
+                unknown3: 0
+            })
+            await this.packetHighwayClient.upload(
+                95,
+                fs.createReadStream(file.filePath, {highWaterMark: BlockSize}),
+                file.fileSize,
+                file.fileMd5,
+                ext
+            );
+        }
+        file.fileUuid = preRespData.upload?.uuid;
+        file.fileHash = preRespData.upload?.fileAddon;
+        const FetchExistFileReq = this.packer.packOfflineFileDownloadReq(file.fileUuid!, file.fileHash!, this.sig.uid, peerUid);
+        const resp = await this.packetClient.sendOidbPacket(FetchExistFileReq, true);
+        const oidb_resp = new NapProtoMsg(OidbSvcTrpcTcpBaseRsp).decode(Buffer.from(resp.hex_data, 'hex'));
+        file._e37_800_rsp = new NapProtoMsg(OidbSvcTrpcTcp0XE37_800Response).decode(oidb_resp.body);
+        file._private_send_uid = this.sig.uid;
+        file._private_recv_uid = peerUid;
+    }
 }
--- a/src/core/packet/highway/uploader.ts
+++ b/src/core/packet/highway/uploader.ts
@@ -2,13 +2,13 @@ import * as net from "node:net";
 import * as crypto from "node:crypto";
 import * as http from "node:http";
 import * as stream from "node:stream";
-import {LogWrapper} from "@/common/log";
+import { LogWrapper } from "@/common/log";
 import * as tea from "@/core/packet/utils/crypto/tea";
-import {NapProtoMsg} from "@/core/packet/proto/NapProto";
-import {ReqDataHighwayHead, RespDataHighwayHead} from "@/core/packet/proto/highway/highway";
-import {BlockSize} from "@/core/packet/highway/session";
-import {PacketHighwayTrans} from "@/core/packet/highway/client";
-import {Frame} from "@/core/packet/highway/frame";
+import { NapProtoMsg } from "@/core/packet/proto/NapProto";
+import { ReqDataHighwayHead, RespDataHighwayHead } from "@/core/packet/proto/highway/highway";
+import { BlockSize } from "@/core/packet/highway/session";
+import { PacketHighwayTrans } from "@/core/packet/highway/client";
+import { Frame } from "@/core/packet/highway/frame";

 abstract class HighwayUploader {
    readonly trans: PacketHighwayTrans;
@@ -19,11 +19,20 @@ abstract class HighwayUploader {
        this.logger = logger;
    }

-    encryptTransExt(key: Uint8Array) {
+    private encryptTransExt(key: Uint8Array) {
        if (!this.trans.encrypt) return;
        this.trans.ext = tea.encrypt(Buffer.from(this.trans.ext), Buffer.from(key));
    }

+    protected timeout(): Promise<void> {
+        return new Promise<void>((_, reject) => {
+            setTimeout(() => {
+                reject(new Error(`[Highway] timeout after ${this.trans.timeout}s`));
+            }, (this.trans.timeout ?? Infinity) * 1000
+            );
+        })
+    }
+
    buildPicUpHead(offset: number, bodyLength: number, bodyMd5: Uint8Array): Uint8Array {
        return new NapProtoMsg(ReqDataHighwayHead).encode({
            msgBaseHead: {
@@ -53,7 +62,7 @@ abstract class HighwayUploader {
                uint32LoginSigType: 8,
                appId: 1600001604,
            }
-        })
+        });
    }

    abstract upload(): Promise<void>;
@@ -86,15 +95,18 @@ class HighwayTcpUploaderTransform extends stream.Transform {

 export class HighwayTcpUploader extends HighwayUploader {
    async upload(): Promise<void> {
-        const highwayTransForm = new HighwayTcpUploaderTransform(this);
-        const upload = new Promise<void>((resolve, _) => {
+        const controller = new AbortController();
+        const { signal } = controller;
+        const upload = new Promise<void>((resolve, reject) => {
+            const highwayTransForm = new HighwayTcpUploaderTransform(this);
            const socket = net.connect(this.trans.port, this.trans.server, () => {
                this.trans.data.pipe(highwayTransForm).pipe(socket, {end: false});
-            })
+            });
            const handleRspHeader = (header: Buffer) => {
                const rsp = new NapProtoMsg(RespDataHighwayHead).decode(header);
                if (rsp.errorCode !== 0) {
-                    this.logger.logWarn(`[Highway] tcpUpload failed (code: ${rsp.errorCode})`);
+                    socket.end();
+                    reject(new Error(`[Highway] tcpUpload failed (code=${rsp.errorCode})`));
                }
                const percent = ((Number(rsp.msgSegHead?.dataOffset) + Number(rsp.msgSegHead?.dataLength)) / Number(rsp.msgSegHead?.filesize)).toFixed(2);
                this.logger.logDebug(`[Highway] tcpUpload ${rsp.errorCode} | ${percent} | ${Buffer.from(header).toString('hex')}`);
@@ -105,62 +117,69 @@ export class HighwayTcpUploader extends HighwayUploader {
                }
            };
            socket.on('data', (chunk: Buffer) => {
-                try {
-                    const [head, _] = Frame.unpack(chunk);
-                    handleRspHeader(head);
-                } catch (e) {
-                    this.logger.logError(`[Highway] tcpUpload parse response error: ${e}`);
+                if (signal.aborted) {
+                    socket.end();
+                    reject(new Error('Upload aborted due to timeout'));
                }
-            })
+                const [head, _] = Frame.unpack(chunk);
+                handleRspHeader(head);
+            });
            socket.on('close', () => {
                this.logger.logDebug('[Highway] tcpUpload socket closed.');
                resolve();
-            })
+            });
            socket.on('error', (err) => {
-                this.logger.logError('[Highway] tcpUpload socket.on error:', err);
-            })
-            this.trans.data.on('error', (err) => {
-                this.logger.logError('[Highway] tcpUpload readable error:', err);
                socket.end();
-            })
-        })
-        const timeout = new Promise<void>((_, reject) => {
-            setTimeout(() => {
-                reject(new Error(`[Highway] tcpUpload timeout after ${this.trans.timeout}s`))
-            }, (this.trans.timeout ?? Infinity) * 1000
-            )
-        })
+                reject(new Error(`[Highway] tcpUpload socket.on error: ${err}`));
+            });
+            this.trans.data.on('error', (err) => {
+                socket.end();
+                reject(new Error(`[Highway] tcpUpload readable error: ${err}`));
+            });
+        });
+        const timeout = this.timeout().catch((err) => {
+            controller.abort();
+            throw new Error(err.message);
+        });
        await Promise.race([upload, timeout]);
    }
 }

-// TODO: timeout impl
 export class HighwayHttpUploader extends HighwayUploader {
    async upload(): Promise<void> {
-        let offset = 0;
-        for await (const chunk of this.trans.data) {
-            let block = chunk as Buffer;
-            try {
-                await this.uploadBlock(block, offset);
-            } catch (err) {
-                this.logger.logError(`[Highway] httpUpload Error uploading block at offset ${offset}: ${err}`);
-                throw err;
+        const controller = new AbortController();
+        const { signal } = controller;
+        const upload = (async () => {
+            let offset = 0;
+            for await (const chunk of this.trans.data) {
+                if (signal.aborted) {
+                    throw new Error('Upload aborted due to timeout');
+                }
+                const block = chunk as Buffer;
+                try {
+                    await this.uploadBlock(block, offset);
+                } catch (err) {
+                    throw new Error(`[Highway] httpUpload Error uploading block at offset ${offset}: ${err}`)
+                }
+                offset += block.length;
            }
-            offset += block.length;
-        }
+        })();
+        const timeout = this.timeout().catch((err) => {
+            controller.abort();
+            throw new Error(err.message);
+        });
+        await Promise.race([upload, timeout]);
    }

    private async uploadBlock(block: Buffer, offset: number): Promise<void> {
        const chunkMD5 = crypto.createHash('md5').update(block).digest();
        const payload = this.buildPicUpHead(offset, block.length, chunkMD5);
-        const frame = Frame.pack(Buffer.from(payload), block)
+        const frame = Frame.pack(Buffer.from(payload), block);
        const resp = await this.httpPostHighwayContent(frame, `http://${this.trans.server}:${this.trans.port}/cgi-bin/httpconn?htcmd=0x6FF0087&uin=${this.trans.uin}`);
        const [head, body] = Frame.unpack(resp);
        const headData = new NapProtoMsg(RespDataHighwayHead).decode(head);
        this.logger.logDebug(`[Highway] httpUploadBlock: ${headData.errorCode} | ${headData.msgSegHead?.retCode} | ${headData.bytesRspExtendInfo} | ${head.toString('hex')} | ${body.toString('hex')}`);
-        if (headData.errorCode !== 0) {
-            this.logger.logError(`[Highway] httpUploadBlock failed (code=${headData.errorCode})`);
-        }
+        if (headData.errorCode !== 0) throw new Error(`[Highway] httpUploadBlock failed (code=${headData.errorCode})`);
    }

    private async httpPostHighwayContent(frame: Buffer, serverURL: string): Promise<Buffer> {
@@ -176,12 +195,12 @@ export class HighwayHttpUploader extends HighwayUploader {
                    },
                };
                const req = http.request(serverURL, options, (res) => {
-                    let data = Buffer.alloc(0);
+                    const data: Buffer[] = [];
                    res.on('data', (chunk) => {
-                        data = Buffer.concat([data, chunk]);
+                        data.push(chunk);
                    });
                    res.on('end', () => {
-                        resolve(data);
+                        resolve(Buffer.concat(data));
                    });
                });
                req.write(frame);
--- a/src/core/packet/highway/utils.ts
+++ b/src/core/packet/highway/utils.ts
@@ -1,11 +1,11 @@
-import {NapProtoEncodeStructType} from "@/core/packet/proto/NapProto";
-import {IPv4} from "@/core/packet/proto/oidb/common/Ntv2.RichMediaResp";
-import {NTHighwayIPv4} from "@/core/packet/proto/highway/highway";
+import { NapProtoEncodeStructType } from "@/core/packet/proto/NapProto";
+import { IPv4 } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaResp";
+import { NTHighwayIPv4 } from "@/core/packet/proto/highway/highway";

 export const int32ip2str = (ip: number) => {
    ip = ip & 0xffffffff;
    return [ip & 0xff, (ip & 0xff00) >> 8, (ip & 0xff0000) >> 16, ((ip & 0xff000000) >> 24) & 0xff].join('.');
-}
+};

 export const oidbIpv4s2HighwayIpv4s = (ipv4s: NapProtoEncodeStructType<typeof IPv4>[]): NapProtoEncodeStructType<typeof NTHighwayIPv4>[] =>{
    return ipv4s.map((ip) => {
@@ -15,6 +15,6 @@ export const oidbIpv4s2HighwayIpv4s = (ipv4s: NapProtoEncodeStructType<typeof IP
                ip: int32ip2str(ip.outIP!),
            },
            port: ip.outPort!
-        } as NapProtoEncodeStructType<typeof NTHighwayIPv4>
-    })
-}
+        } as NapProtoEncodeStructType<typeof NTHighwayIPv4>;
+    });
+};
--- a/src/core/packet/msg/builder.ts
+++ b/src/core/packet/msg/builder.ts
@@ -1,8 +1,10 @@
 import * as crypto from "crypto";
-import {PushMsgBody} from "@/core/packet/proto/message/message";
-import {NapProtoEncodeStructType} from "@/core/packet/proto/NapProto";
-import {LogWrapper} from "@/common/log";
-import {PacketMsg} from "@/core/packet/msg/message";
+import { PushMsgBody } from "@/core/packet/proto/message/message";
+import { NapProtoEncodeStructType } from "@/core/packet/proto/NapProto";
+import { LogWrapper } from "@/common/log";
+import { PacketMsg, PacketSendMsgElement } from "@/core/packet/msg/message";
+import { IPacketMsgElement, PacketMsgTextElement } from "@/core/packet/msg/element";
+import { SendTextElement } from "@/core";

 export class PacketMsgBuilder {
    private logger: LogWrapper;
@@ -11,10 +13,23 @@ export class PacketMsgBuilder {
        this.logger = logger;
    }

+    protected static failBackText = new PacketMsgTextElement(
+        {
+            textElement: {content: "[该消息类型暂不支持查看]"}!
+        } as SendTextElement
+    )
+
    buildFakeMsg(selfUid: string, element: PacketMsg[]): NapProtoEncodeStructType<typeof PushMsgBody>[] {
        return element.map((node): NapProtoEncodeStructType<typeof PushMsgBody> => {
            const avatar = `https://q.qlogo.cn/headimg_dl?dst_uin=${node.senderUin}&spec=640&img_type=jpg`;
+            const msgContent = node.msg.reduceRight((acc: undefined | Uint8Array, msg: IPacketMsgElement<PacketSendMsgElement>) => {
+                return acc !== undefined ? acc : msg.buildContent();
+            }, undefined);
            const msgElement = node.msg.flatMap(msg => msg.buildElement() ?? []);
+            if (!msgContent && !msgElement.length) {
+                this.logger.logWarn(`[PacketMsgBuilder] buildFakeMsg: 空的msgContent和msgElement！`);
+                msgElement.push(PacketMsgBuilder.failBackText.buildElement());
+            }
            return {
                responseHead: {
                    fromUid: "",
@@ -50,7 +65,8 @@ export class PacketMsgBuilder {
                body: {
                    richText: {
                        elems: msgElement
-                    }
+                    },
+                    msgContent: msgContent,
                }
            };
        });
--- a/src/core/packet/msg/converter.ts
+++ b/src/core/packet/msg/converter.ts
@@ -28,8 +28,8 @@ import {
    PacketMsgVideoElement,
    PacketMultiMsgElement
 } from "@/core/packet/msg/element";
-import {PacketMsg, PacketSendMsgElement} from "@/core/packet/msg/message";
-import {LogWrapper} from "@/common/log";
+import { PacketMsg, PacketSendMsgElement } from "@/core/packet/msg/message";
+import { LogWrapper } from "@/common/log";

 type SendMessageElementMap = {
    textElement: SendTextElement,
@@ -82,50 +82,50 @@ export class PacketMsgConverter {
                );
                if (key) {
                    const elementData = (element as any)[key];  // TODO:
-                    if (elementData) return this.rawToPacketMsgConverters[key](element as any)
+                    if (elementData) return this.rawToPacketMsgConverters[key](element as any);
                }
                return null;
            }).filter((e) => e !== null)
-        }
+        };
    }

    private rawToPacketMsgConverters: RawToPacketMsgConverters = {
        textElement: (element: SendTextElement) => {
            if (element.textElement.atType) {
-                return new PacketMsgAtElement(element)
+                return new PacketMsgAtElement(element);
            }
-            return new PacketMsgTextElement(element)
+            return new PacketMsgTextElement(element);
        },
        picElement: (element: SendPicElement) => {
-            return new PacketMsgPicElement(element)
+            return new PacketMsgPicElement(element);
        },
        replyElement: (element: SendReplyElement) => {
-            return new PacketMsgReplyElement(element)
+            return new PacketMsgReplyElement(element);
        },
        faceElement: (element: SendFaceElement) => {
-            return new PacketMsgFaceElement(element)
+            return new PacketMsgFaceElement(element);
        },
        marketFaceElement: (element: SendMarketFaceElement) => {
-            return new PacketMsgMarkFaceElement(element)
+            return new PacketMsgMarkFaceElement(element);
        },
        videoElement: (element: SendVideoElement) => {
-            return new PacketMsgVideoElement(element)
+            return new PacketMsgVideoElement(element);
        },
        fileElement: (element: SendFileElement) => {
-            return new PacketMsgFileElement(element)
+            return new PacketMsgFileElement(element);
        },
        pttElement: (element: SendPttElement) => {
-            return new PacketMsgPttElement(element)
+            return new PacketMsgPttElement(element);
        },
        arkElement: (element: SendArkElement) => {
-            return new PacketMsgLightAppElement(element)
+            return new PacketMsgLightAppElement(element);
        },
        markdownElement: (element: SendMarkdownElement) => {
-            return new PacketMsgMarkDownElement(element)
+            return new PacketMsgMarkDownElement(element);
        },
        // TODO: check this logic, move it in arkElement?
        structLongMsgElement: (element: SendStructLongMsgElement) => {
-            return new PacketMultiMsgElement(element)
+            return new PacketMultiMsgElement(element);
        }
-    }
+    };
 }
--- a/src/core/packet/msg/element.ts
+++ b/src/core/packet/msg/element.ts
@@ -1,7 +1,5 @@
-import assert from "node:assert";
 import * as zlib from "node:zlib";
-import * as crypto from "node:crypto";
-import {NapProtoEncodeStructType, NapProtoMsg} from "@/core/packet/proto/NapProto";
+import { NapProtoEncodeStructType, NapProtoMsg } from "@/core/packet/proto/NapProto";
 import {
    CustomFace,
    Elem,
@@ -26,27 +24,32 @@ import {
    SendTextElement,
    SendVideoElement
 } from "@/core";
-import {MsgInfo} from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";
-import {PacketMsg, PacketSendMsgElement} from "@/core/packet/msg/message";
+import { MsgInfo } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";
+import { PacketMsg, PacketSendMsgElement } from "@/core/packet/msg/message";
+import { ForwardMsgBuilder } from "@/common/forward-msg-builder";
+import { FileExtra, GroupFileExtra } from "@/core/packet/proto/message/component";
+import { OidbSvcTrpcTcp0XE37_800Response } from "@/core/packet/proto/oidb/Oidb.0XE37_800";

 // raw <-> packet
-// TODO: check ob11 -> raw impl!
-// TODO: parse to raw element
 // TODO: SendStructLongMsgElement
 export abstract class IPacketMsgElement<T extends PacketSendMsgElement> {
    protected constructor(rawElement: T) {
    }

+    get valid(): boolean {
+        return true;
+    }
+
    buildContent(): Uint8Array | undefined {
        return undefined;
    }

-    buildElement(): NapProtoEncodeStructType<typeof Elem>[] | undefined {
-        return undefined;
+    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
+        return [];
    }

    toPreview(): string {
-        return '[nya~]';
+        return '[暂不支持该消息类型喵~]';
    }
 }

@@ -95,50 +98,6 @@ export class PacketMsgAtElement extends PacketMsgTextElement {
            }
        }];
    }
-
-    toPreview(): string {
-        return `@${this.targetUid} ${this.text}`;
-    }
-}
-
-export class PacketMsgPicElement extends IPacketMsgElement<SendPicElement> {
-    path: string;
-    name: string
-    size: number;
-    md5: string;
-    width: number;
-    height: number;
-    picType: PicType;
-    sha1: string | null = null;
-    msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;
-    groupPicExt: NapProtoEncodeStructType<typeof CustomFace> | null = null;
-    c2cPicExt: NapProtoEncodeStructType<typeof NotOnlineImage> | null = null;
-
-    constructor(element: SendPicElement) {
-        super(element);
-        this.path = element.picElement.sourcePath;
-        this.name = element.picElement.fileName;
-        this.size = Number(element.picElement.fileSize);
-        this.md5 = element.picElement.md5HexStr ?? '';
-        this.width = element.picElement.picWidth;
-        this.height = element.picElement.picHeight;
-        this.picType = element.picElement.picType;
-    }
-
-    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
-        assert(this.msgInfo !== null, 'msgInfo is null, expected not null');
-        return [{
-            commonElem: {
-                serviceType: 48,
-                pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
-                businessType: 10,
-            }
-        }]
-    }
-
-    toPreview(): string {
-        return "[图片]";
-    }
 }

 export class PacketMsgReplyElement extends IPacketMsgElement<SendReplyElement> {
@@ -153,11 +112,11 @@ export class PacketMsgReplyElement extends IPacketMsgElement<SendReplyElement> {
    constructor(element: SendReplyElement) {
        super(element);
        this.messageId = BigInt(element.replyElement.replayMsgId ?? 0);
-        this.messageSeq = Number(element.replyElement.replayMsgSeq ?? 0);
-        this.messageClientSeq = Number(element.replyElement.replyMsgClientSeq ?? 0);
-        this.targetUin = Number(element.replyElement.senderUin ?? 0);
+        this.messageSeq = +(element.replyElement.replayMsgSeq ?? 0);
+        this.messageClientSeq = +(element.replyElement.replyMsgClientSeq ?? 0);
+        this.targetUin = +(element.replyElement.senderUin ?? 0);
        this.targetUid = element.replyElement.senderUidStr ?? '';
-        this.time = Number(element.replyElement.replyMsgTime ?? 0);
+        this.time = +(element.replyElement.replyMsgTime ?? 0);
        this.elems = []; // TODO: in replyElement.sourceMsgTextElems
    }

@@ -187,11 +146,11 @@ export class PacketMsgReplyElement extends IPacketMsgElement<SendReplyElement> {
                    uid: String(this.targetUid),
                }),
            } : undefined,
-        }]
+        }];
    }

    toPreview(): string {
-        return "[回复]";
+        return "[回复消息]";
    }
 }

@@ -221,7 +180,7 @@ export class PacketMsgFaceElement extends IPacketMsgElement<SendFaceElement> {
                    }),
                    businessType: 1
                }
-            }]
+            }];
        } else if (this.faceId < 260) {
            return [{
                face: {
@@ -239,7 +198,7 @@ export class PacketMsgFaceElement extends IPacketMsgElement<SendFaceElement> {
                    }),
                    businessType: 1
                }
-            }]
+            }];
        }
    }

@@ -278,29 +237,224 @@ export class PacketMsgMarkFaceElement extends IPacketMsgElement<SendMarketFaceEl
                    field8: 1
                }
            }
-        }]
+        }];
    }

    toPreview(): string {
-        return this.emojiName;
+        return `[${this.emojiName}]`;
+    }
+}
+
+export class PacketMsgPicElement extends IPacketMsgElement<SendPicElement> {
+    path: string;
+    name: string;
+    size: number;
+    md5: string;
+    width: number;
+    height: number;
+    picType: PicType;
+    sha1: string | null = null;
+    msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;
+    groupPicExt: NapProtoEncodeStructType<typeof CustomFace> | null = null;
+    c2cPicExt: NapProtoEncodeStructType<typeof NotOnlineImage> | null = null;
+
+    constructor(element: SendPicElement) {
+        super(element);
+        this.path = element.picElement.sourcePath;
+        this.name = element.picElement.fileName;
+        this.size = +element.picElement.fileSize;
+        this.md5 = element.picElement.md5HexStr ?? '';
+        this.width = element.picElement.picWidth;
+        this.height = element.picElement.picHeight;
+        this.picType = element.picElement.picType;
+    }
+
+    get valid(): boolean {
+        return !!this.msgInfo;
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
+        if (!this.msgInfo) return [];
+        return [{
+            commonElem: {
+                serviceType: 48,
+                pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
+                businessType: 10,
+            }
+        }];
+    }
+
+    toPreview(): string {
+        return "[图片]";
    }
 }

 export class PacketMsgVideoElement extends IPacketMsgElement<SendVideoElement> {
+    fileSize?: string;
+    filePath?: string;
+    thumbSize?: number;
+    thumbPath?: string;
+    fileMd5?: string;
+    fileSha1?: string;
+    thumbMd5?: string;
+    thumbSha1?: string;
+    thumbWidth?: number;
+    thumbHeight?: number;
+    msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;
+
    constructor(element: SendVideoElement) {
        super(element);
+        this.fileSize = element.videoElement.fileSize;
+        this.filePath = element.videoElement.filePath;
+        this.thumbSize = element.videoElement.thumbSize;
+        this.thumbPath = element.videoElement.thumbPath?.get(0);
+        this.fileMd5 = element.videoElement.videoMd5
+        this.thumbMd5 = element.videoElement.thumbMd5;
+        this.thumbWidth = element.videoElement.thumbWidth;
+        this.thumbHeight = element.videoElement.thumbHeight;
    }
-}

-export class PacketMsgFileElement extends IPacketMsgElement<SendFileElement> {
-    constructor(element: SendFileElement) {
-        super(element);
+    get valid(): boolean {
+        return !!this.msgInfo;
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
+        if (!this.msgInfo) return [];
+        return [{
+            commonElem: {
+                serviceType: 48,
+                pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
+                businessType: 21,
+            }
+        }];
+    }
+
+    toPreview(): string {
+        return "[视频]";
    }
 }

 export class PacketMsgPttElement extends IPacketMsgElement<SendPttElement> {
+    filePath: string;
+    fileSize: number;
+    fileMd5: string;
+    fileSha1?: string;
+    fileDuration: number;
+    msgInfo: NapProtoEncodeStructType<typeof MsgInfo> | null = null;
+
    constructor(element: SendPttElement) {
        super(element);
+        this.filePath = element.pttElement.filePath;
+        this.fileSize = +element.pttElement.fileSize; // TODO: cc
+        this.fileMd5 = element.pttElement.md5HexStr;
+        this.fileDuration = Math.round(element.pttElement.duration); // TODO: cc
+    }
+
+    get valid(): boolean {
+        return false;
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
+        return []
+        // if (!this.msgInfo) return [];
+        // return [{
+        //     commonElem: {
+        //         serviceType: 48,
+        //         pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
+        //         businessType: 22,
+        //     }
+        // }];
+    }
+
+    toPreview(): string {
+        return "[语音]";
+    }
+}
+
+export class PacketMsgFileElement extends IPacketMsgElement<SendFileElement> {
+    fileName: string;
+    filePath: string;
+    fileSize: number;
+    fileSha1?: Uint8Array;
+    fileMd5?: Uint8Array;
+    fileUuid?: string;
+    fileHash?: string;
+    isGroupFile?: boolean;
+    _private_send_uid?: string;
+    _private_recv_uid?: string;
+    _e37_800_rsp?: NapProtoEncodeStructType<typeof OidbSvcTrpcTcp0XE37_800Response>
+
+    constructor(element: SendFileElement) {
+        super(element);
+        this.fileName = element.fileElement.fileName;
+        this.filePath = element.fileElement.filePath;
+        this.fileSize = +element.fileElement.fileSize;
+    }
+
+    get valid(): boolean {
+        return this.isGroupFile || Boolean(this._e37_800_rsp);
+    }
+
+    buildContent(): Uint8Array | undefined {
+        if (this.isGroupFile || !this._e37_800_rsp) return undefined;
+        return new NapProtoMsg(FileExtra).encode({
+            file: {
+                fileType: 0,
+                fileUuid: this.fileUuid,
+                fileMd5: this.fileMd5,
+                fileName: this.fileName,
+                fileSize: BigInt(this.fileSize),
+                subcmd: 1,
+                dangerEvel: 0,
+                expireTime: Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60,
+                fileHash: this.fileHash,
+            },
+            field6: {
+                field2: {
+                    field1: this._e37_800_rsp?.body?.field30?.field110,
+                    fileUuid: this.fileUuid,
+                    fileName: this.fileName,
+                    field6: this._e37_800_rsp?.body?.field30?.field3,
+                    field7: this._e37_800_rsp?.body?.field30?.field101,
+                    field8: this._e37_800_rsp?.body?.field30?.field100,
+                    timestamp1: this._e37_800_rsp?.body?.field30?.timestamp1,
+                    fileHash: this.fileHash,
+                    selfUid: this._private_send_uid,
+                    destUid: this._private_recv_uid,
+                }
+            }
+        })
+    }
+
+    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
+        if (!this.isGroupFile) return [];
+        const lb = Buffer.alloc(2);
+        const transElemVal = new NapProtoMsg(GroupFileExtra).encode({
+            field1: 6,
+            fileName: this.fileName,
+            inner: {
+                info: {
+                    busId: 102,
+                    fileId: this.fileUuid,
+                    fileSize: BigInt(this.fileSize),
+                    fileName: this.fileName,
+                    fileSha: this.fileSha1,
+                    extInfoString: "",
+                    fileMd5: this.fileMd5,
+                }
+            }
+        })
+        lb.writeUInt16BE(transElemVal.length);
+        return [{
+            transElem: {
+                elemType: 24,
+                elemValue: Buffer.concat([Buffer.from([0x01]), lb, transElemVal]) // TLV
+            }
+        }];
+    }
+
+    toPreview(): string {
+        return `[文件]${this.fileName}`;
    }
 }

@@ -320,11 +474,11 @@ export class PacketMsgLightAppElement extends IPacketMsgElement<SendArkElement>
                    zlib.deflateSync(Buffer.from(this.payload, 'utf-8'))
                ])
            }
-        }]
+        }];
    }

    toPreview(): string {
-        return "[小程序]";
+        return "[卡片消息]";
    }
 }

@@ -345,11 +499,11 @@ export class PacketMsgMarkDownElement extends IPacketMsgElement<SendMarkdownElem
                }),
                businessType: 1
            }
-        }]
+        }];
    }

    toPreview(): string {
-        return this.content;
+        return `[Markdown消息 ${this.content}]`;
    }
 }

@@ -363,58 +517,15 @@ export class PacketMultiMsgElement extends IPacketMsgElement<SendStructLongMsgEl
        this.message = message ?? [];
    }

-    get isGroupMsg(): boolean {
-        return this.message.some(msg => msg.groupId !== undefined);
-    }
-
-    get JSON() {
-        const id = crypto.randomUUID();
-        return {
-            app: "com.tencent.multimsg",
-            config: {
-                autosize: 1,
-                forward: 1,
-                round: 1,
-                type: "normal",
-                width: 300
-            },
-            desc: "[聊天记录]",
-            extra: {
-                filename: id,
-                tsum: this.message.length,
-            },
-            meta: {
-                detail: {
-                    news: this.message.length === 0 ? [{
-                        text: "[Nya~ This message is send from NapCat.Packet!]",
-                    }] : this.message.map(packetMsg => ({
-                        text: `${packetMsg.senderName}: ${packetMsg.msg.map(msg => msg.toPreview()).join('')}`,
-                    })),
-                    resid: this.resid,
-                    source: this.isGroupMsg ? "群聊的聊天记录" :
-                        this.message.length
-                            ? Array.from(new Set(this.message.map(msg => msg.senderName)))
-                            .join('和') + '的聊天记录'
-                            : '聊天记录',
-                    summary: `查看${this.message.length}条转发消息`,
-                    uniseq: id,
-                }
-            },
-            prompt: "[聊天记录]",
-            ver: "0.0.0.5",
-            view: "contact",
-        }
-    }
-
    buildElement(): NapProtoEncodeStructType<typeof Elem>[] {
        return [{
            lightAppElem: {
                data: Buffer.concat([
                    Buffer.from([0x01]),
-                    zlib.deflateSync(Buffer.from(JSON.stringify(this.JSON), 'utf-8'))
+                    zlib.deflateSync(Buffer.from(JSON.stringify(ForwardMsgBuilder.fromPacketMsg(this.resid, this.message)), 'utf-8'))
                ])
            }
-        }]
+        }];
    }

    toPreview(): string {
--- a/src/core/packet/msg/message.ts
+++ b/src/core/packet/msg/message.ts
@@ -1,5 +1,5 @@
-import {IPacketMsgElement} from "@/core/packet/msg/element";
-import {SendMessageElement, SendStructLongMsgElement} from "@/core";
+import { IPacketMsgElement } from "@/core/packet/msg/element";
+import { SendMessageElement, SendStructLongMsgElement } from "@/core";

 export type PacketSendMsgElement = SendMessageElement | SendStructLongMsgElement

--- a/src/core/packet/packer.ts
+++ b/src/core/packet/packer.ts
@@ -1,26 +1,39 @@
 import * as zlib from "node:zlib";
 import * as crypto from "node:crypto";
-import {calculateSha1} from "@/core/packet/utils/crypto/hash"
-import {NapProtoMsg} from "@/core/packet/proto/NapProto";
-import {OidbSvcTrpcTcpBase} from "@/core/packet/proto/oidb/OidbBase";
-import {OidbSvcTrpcTcp0X9067_202} from "@/core/packet/proto/oidb/Oidb.0x9067_202";
-import {OidbSvcTrpcTcp0X8FC_2, OidbSvcTrpcTcp0X8FC_2_Body} from "@/core/packet/proto/oidb/Oidb.0x8FC_2";
-import {OidbSvcTrpcTcp0XFE1_2} from "@/core/packet/proto/oidb/Oidb.0XFE1_2";
-import {OidbSvcTrpcTcp0XED3_1} from "@/core/packet/proto/oidb/Oidb.0xED3_1";
-import {NTV2RichMediaReq} from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";
-import {HttpConn0x6ff_501} from "@/core/packet/proto/action/action";
-import {LongMsgResult, SendLongMsgReq} from "@/core/packet/proto/message/action";
-import {PacketMsgBuilder} from "@/core/packet/msg/builder";
-import {PacketMsgPicElement} from "@/core/packet/msg/element";
-import {LogWrapper} from "@/common/log";
-import {PacketMsg} from "@/core/packet/msg/message";
-import {OidbSvcTrpcTcp0x6D6} from "@/core/packet/proto/oidb/Oidb.0x6D6";
-import {OidbSvcTrpcTcp0XE37_1200} from "@/core/packet/proto/oidb/Oidb.0xE37_1200";
-import {PacketMsgConverter} from "@/core/packet/msg/converter";
-import {PacketClient} from "@/core/packet/client";
+import { computeMd5AndLengthWithLimit } from "@/core/packet/utils/crypto/hash";
+import { NapProtoMsg } from "@/core/packet/proto/NapProto";
+import { OidbSvcTrpcTcpBase } from "@/core/packet/proto/oidb/OidbBase";
+import { OidbSvcTrpcTcp0X9067_202 } from "@/core/packet/proto/oidb/Oidb.0x9067_202";
+import { OidbSvcTrpcTcp0X8FC_2, OidbSvcTrpcTcp0X8FC_2_Body } from "@/core/packet/proto/oidb/Oidb.0x8FC_2";
+import { OidbSvcTrpcTcp0XFE1_2 } from "@/core/packet/proto/oidb/Oidb.0XFE1_2";
+import { OidbSvcTrpcTcp0XED3_1 } from "@/core/packet/proto/oidb/Oidb.0xED3_1";
+import { NTV2RichMediaReq } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";
+import { HttpConn0x6ff_501 } from "@/core/packet/proto/action/action";
+import { LongMsgResult, SendLongMsgReq } from "@/core/packet/proto/message/action";
+import { PacketMsgBuilder } from "@/core/packet/msg/builder";
+import {
+    PacketMsgFileElement,
+    PacketMsgPicElement,
+    PacketMsgPttElement,
+    PacketMsgVideoElement
+} from "@/core/packet/msg/element";
+import { LogWrapper } from "@/common/log";
+import { PacketMsg } from "@/core/packet/msg/message";
+import { OidbSvcTrpcTcp0x6D6 } from "@/core/packet/proto/oidb/Oidb.0x6D6";
+import { OidbSvcTrpcTcp0XE37_1200 } from "@/core/packet/proto/oidb/Oidb.0xE37_1200";
+import { PacketMsgConverter } from "@/core/packet/msg/converter";
+import { PacketClient } from "@/core/packet/client";
+import { OidbSvcTrpcTcp0XE37_1700 } from "@/core/packet/proto/oidb/Oidb.0xE37_1700";
+import { OidbSvcTrpcTcp0XE37_800 } from "@/core/packet/proto/oidb/Oidb.0XE37_800";
+import { OidbSvcTrpcTcp0XEB7 } from "./proto/oidb/Oidb.0xEB7";

 export type PacketHexStr = string & { readonly hexNya: unique symbol };

+export interface OidbPacket {
+    cmd: string;
+    data: PacketHexStr
+}
+
 export class PacketPacker {
    readonly logger: LogWrapper;
    readonly client: PacketClient;
@@ -34,30 +47,34 @@ export class PacketPacker {
        this.packetConverter = new PacketMsgConverter(logger);
    }

-    private toHexStr(byteArray: Uint8Array): PacketHexStr {
+    private packetPacket(byteArray: Uint8Array): PacketHexStr {
        return Buffer.from(byteArray).toString('hex') as PacketHexStr;
    }

-    packOidbPacket(cmd: number, subCmd: number, body: Uint8Array, isUid: boolean = true, isLafter: boolean = false): Uint8Array {
-        return new NapProtoMsg(OidbSvcTrpcTcpBase).encode({
+    packOidbPacket(cmd: number, subCmd: number, body: Uint8Array, isUid: boolean = true, isLafter: boolean = false): OidbPacket {
+        const data = new NapProtoMsg(OidbSvcTrpcTcpBase).encode({
            command: cmd,
            subCommand: subCmd,
            body: body,
            isReserved: isUid ? 1 : 0
        });
+        return {
+            cmd: `OidbSvcTrpcTcp.0x${cmd.toString(16).toUpperCase()}_${subCmd}`,
+            data: this.packetPacket(data)
+        }
    }

-    packPokePacket(group: number, peer: number): PacketHexStr {
+    packPokePacket(peer: number, group?: number): OidbPacket {
        const oidb_0xed3 = new NapProtoMsg(OidbSvcTrpcTcp0XED3_1).encode({
            uin: peer,
            groupUin: group,
-            friendUin: group,
+            friendUin: group ?? peer,
            ext: 0
        });
-        return this.toHexStr(this.packOidbPacket(0xed3, 1, oidb_0xed3));
+        return this.packOidbPacket(0xed3, 1, oidb_0xed3);
    }

-    packRkeyPacket(): PacketHexStr {
+    packRkeyPacket(): OidbPacket {
        const oidb_0x9067_202 = new NapProtoMsg(OidbSvcTrpcTcp0X9067_202).encode({
            reqHead: {
                common: {
@@ -77,10 +94,10 @@ export class PacketPacker {
                key: [10, 20, 2]
            },
        });
-        return this.toHexStr(this.packOidbPacket(0x9067, 202, oidb_0x9067_202));
+        return this.packOidbPacket(0x9067, 202, oidb_0x9067_202);
    }

-    packSetSpecialTittlePacket(groupCode: string, uid: string, tittle: string): PacketHexStr {
+    packSetSpecialTittlePacket(groupCode: string, uid: string, tittle: string): OidbPacket {
        const oidb_0x8FC_2_body = new NapProtoMsg(OidbSvcTrpcTcp0X8FC_2_Body).encode({
            targetUid: uid,
            specialTitle: tittle,
@@ -91,15 +108,15 @@ export class PacketPacker {
            groupUin: +groupCode,
            body: oidb_0x8FC_2_body
        });
-        return this.toHexStr(this.packOidbPacket(0x8FC, 2, oidb_0x8FC_2, false, false));
+        return this.packOidbPacket(0x8FC, 2, oidb_0x8FC_2, false, false);
    }

-    packStatusPacket(uin: number): PacketHexStr {
+    packStatusPacket(uin: number): OidbPacket {
        const oidb_0xfe1_2 = new NapProtoMsg(OidbSvcTrpcTcp0XFE1_2).encode({
            uin: uin,
            key: [{key: 27372}]
        });
-        return this.toHexStr(this.packOidbPacket(0xfe1, 2, oidb_0xfe1_2));
+        return this.packOidbPacket(0xfe1, 2, oidb_0xfe1_2);
    }

    async packUploadForwardMsg(selfUid: string, msg: PacketMsg[], groupUin: number = 0): Promise<PacketHexStr> {
@@ -131,12 +148,12 @@ export class PacketPacker {
            }
        );
        // this.logger.logDebug("packUploadForwardMsg REQ!!!", req);
-        return this.toHexStr(req);
+        return this.packetPacket(req);
    }

    // highway part
    packHttp0x6ff_501(): PacketHexStr {
-        return this.toHexStr(new NapProtoMsg(HttpConn0x6ff_501).encode({
+        return this.packetPacket(new NapProtoMsg(HttpConn0x6ff_501).encode({
            httpConn: {
                field1: 0,
                field2: 0,
@@ -153,7 +170,7 @@ export class PacketPacker {
        }));
    }

-    async packUploadGroupImgReq(groupUin: number, img: PacketMsgPicElement): Promise<PacketHexStr> {
+    async packUploadGroupImgReq(groupUin: number, img: PacketMsgPicElement): Promise<OidbPacket> {
        const req = new NapProtoMsg(NTV2RichMediaReq).encode(
            {
                reqHead: {
@@ -177,9 +194,9 @@ export class PacketPacker {
                    uploadInfo: [
                        {
                            fileInfo: {
-                                fileSize: Number(img.size),
+                                fileSize: +img.size,
                                fileHash: img.md5,
-                                fileSha1: this.toHexStr(await calculateSha1(img.path)),
+                                fileSha1: img.sha1!,
                                fileName: img.name,
                                type: {
                                    type: 1,
@@ -217,11 +234,11 @@ export class PacketPacker {
                    noNeedCompatMsg: false,
                }
            }
-        )
-        return this.toHexStr(this.packOidbPacket(0x11c4, 100, req, true, false));
+        );
+        return this.packOidbPacket(0x11c4, 100, req, true, false);
    }

-    async packUploadC2CImgReq(peerUin: string, img: PacketMsgPicElement): Promise<PacketHexStr> {
+    async packUploadC2CImgReq(peerUin: string, img: PacketMsgPicElement): Promise<OidbPacket> {
        const req = new NapProtoMsg(NTV2RichMediaReq).encode({
                reqHead: {
                    common: {
@@ -245,9 +262,9 @@ export class PacketPacker {
                    uploadInfo: [
                        {
                            fileInfo: {
-                                fileSize: Number(img.size),
+                                fileSize: +img.size,
                                fileHash: img.md5,
-                                fileSha1: this.toHexStr(await calculateSha1(img.path)),
+                                fileSha1: img.sha1!,
                                fileName: img.name,
                                type: {
                                    type: 1,
@@ -285,25 +302,380 @@ export class PacketPacker {
                    noNeedCompatMsg: false,
                }
            }
-        )
-        return this.toHexStr(this.packOidbPacket(0x11c5, 100, req, true, false));
+        );
+        return this.packOidbPacket(0x11c5, 100, req, true, false);
    }

-    packGroupFileDownloadReq(groupUin: number, fileUUID: string): PacketHexStr {
-        return this.toHexStr(
-            this.packOidbPacket(0x6D6, 2, new NapProtoMsg(OidbSvcTrpcTcp0x6D6).encode({
+    async packUploadGroupVideoReq(groupUin: number, video: PacketMsgVideoElement): Promise<OidbPacket> {
+        if (!video.fileSize || !video.thumbSize) throw new Error("video.fileSize or video.thumbSize is empty");
+        const req = new NapProtoMsg(NTV2RichMediaReq).encode({
+            reqHead: {
+                common: {
+                    requestId: 3,
+                    command: 100
+                },
+                scene: {
+                    requestType: 2,
+                    businessType: 2,
+                    sceneType: 2,
+                    group: {
+                        groupUin: groupUin
+                    },
+                },
+                client: {
+                    agentType: 2
+                }
+            },
+            upload: {
+                uploadInfo: [
+                    {
+                        fileInfo: {
+                            fileSize: +video.fileSize,
+                            fileHash: video.fileMd5,
+                            fileSha1: video.fileSha1,
+                            fileName: "nya.mp4",
+                            type: {
+                                type: 2,
+                                picFormat: 0,
+                                videoFormat: 0,
+                                voiceFormat: 0
+                            },
+                            height: 0,
+                            width: 0,
+                            time: 0,
+                            original: 0
+                        },
+                        subFileType: 0
+                    }, {
+                        fileInfo: {
+                            fileSize: +video.thumbSize,
+                            fileHash: video.thumbMd5,
+                            fileSha1: video.thumbSha1,
+                            fileName: "nya.jpg",
+                            type: {
+                                type: 1,
+                                picFormat: 0,
+                                videoFormat: 0,
+                                voiceFormat: 0
+                            },
+                            height: video.thumbHeight,
+                            width: video.thumbWidth,
+                            time: 0,
+                            original: 0
+                        },
+                        subFileType: 100
+                    }
+                ],
+                tryFastUploadCompleted: true,
+                srvSendMsg: false,
+                clientRandomId: crypto.randomBytes(8).readBigUInt64BE() & BigInt('0x7FFFFFFFFFFFFFFF'),
+                compatQMsgSceneType: 2,
+                extBizInfo: {
+                    pic: {
+                        bizType: 0,
+                        textSummary: "Nya~",
+                    },
+                    video: {
+                        bytesPbReserve: Buffer.from([0x80, 0x01, 0x00]),
+                    },
+                    ptt: {
+                        bytesPbReserve: Buffer.alloc(0),
+                        bytesReserve: Buffer.alloc(0),
+                        bytesGeneralFlags: Buffer.alloc(0),
+                    }
+                },
+                clientSeq: 0,
+                noNeedCompatMsg: false
+            }
+        });
+        return this.packOidbPacket(0x11EA, 100, req, true, false);
+    }
+
+    async packUploadC2CVideoReq(peerUin: string, video: PacketMsgVideoElement): Promise<OidbPacket> {
+        if (!video.fileSize || !video.thumbSize) throw new Error("video.fileSize or video.thumbSize is empty");
+        const req = new NapProtoMsg(NTV2RichMediaReq).encode({
+            reqHead: {
+                common: {
+                    requestId: 3,
+                    command: 100
+                },
+                scene: {
+                    requestType: 2,
+                    businessType: 2,
+                    sceneType: 1,
+                    c2C: {
+                        accountType: 2,
+                        targetUid: peerUin
+                    }
+                },
+                client: {
+                    agentType: 2
+                }
+            },
+            upload: {
+                uploadInfo: [
+                    {
+                        fileInfo: {
+                            fileSize: +video.fileSize,
+                            fileHash: video.fileMd5,
+                            fileSha1: video.fileSha1,
+                            fileName: "nya.mp4",
+                            type: {
+                                type: 2,
+                                picFormat: 0,
+                                videoFormat: 0,
+                                voiceFormat: 0
+                            },
+                            height: 0,
+                            width: 0,
+                            time: 0,
+                            original: 0
+                        },
+                        subFileType: 0
+                    }, {
+                        fileInfo: {
+                            fileSize: +video.thumbSize,
+                            fileHash: video.thumbMd5,
+                            fileSha1: video.thumbSha1,
+                            fileName: "nya.jpg",
+                            type: {
+                                type: 1,
+                                picFormat: 0,
+                                videoFormat: 0,
+                                voiceFormat: 0
+                            },
+                            height: video.thumbHeight,
+                            width: video.thumbWidth,
+                            time: 0,
+                            original: 0
+                        },
+                        subFileType: 100
+                    }
+                ],
+                tryFastUploadCompleted: true,
+                srvSendMsg: false,
+                clientRandomId: crypto.randomBytes(8).readBigUInt64BE() & BigInt('0x7FFFFFFFFFFFFFFF'),
+                compatQMsgSceneType: 2,
+                extBizInfo: {
+                    pic: {
+                        bizType: 0,
+                        textSummary: "Nya~",
+                    },
+                    video: {
+                        bytesPbReserve: Buffer.from([0x80, 0x01, 0x00]),
+                    },
+                    ptt: {
+                        bytesPbReserve: Buffer.alloc(0),
+                        bytesReserve: Buffer.alloc(0),
+                        bytesGeneralFlags: Buffer.alloc(0),
+                    }
+                },
+                clientSeq: 0,
+                noNeedCompatMsg: false
+            }
+        });
+        return this.packOidbPacket(0x11E9, 100, req, true, false);
+    }
+
+    async packUploadGroupPttReq(groupUin: number, ptt: PacketMsgPttElement): Promise<OidbPacket> {
+        const req = new NapProtoMsg(NTV2RichMediaReq).encode({
+            reqHead: {
+                common: {
+                    requestId: 1,
+                    command: 100
+                },
+                scene: {
+                    requestType: 2,
+                    businessType: 3,
+                    sceneType: 2,
+                    group: {
+                        groupUin: groupUin
+                    }
+                },
+                client: {
+                    agentType: 2
+                }
+            },
+            upload: {
+                uploadInfo: [
+                    {
+                        fileInfo: {
+                            fileSize: ptt.fileSize,
+                            fileHash: ptt.fileMd5,
+                            fileSha1: ptt.fileSha1,
+                            fileName: `${ptt.fileMd5}.amr`,
+                            type: {
+                                type: 3,
+                                picFormat: 0,
+                                videoFormat: 0,
+                                voiceFormat: 1
+                            },
+                            height: 0,
+                            width: 0,
+                            time: ptt.fileDuration,
+                            original: 0
+                        },
+                        subFileType: 0
+                    }
+                ],
+                tryFastUploadCompleted: true,
+                srvSendMsg: false,
+                clientRandomId: crypto.randomBytes(8).readBigUInt64BE() & BigInt('0x7FFFFFFFFFFFFFFF'),
+                compatQMsgSceneType: 2,
+                extBizInfo: {
+                    pic: {
+                        textSummary: "Nya~",
+                    },
+                    video: {
+                        bytesPbReserve: Buffer.alloc(0),
+                    },
+                    ptt: {
+                        bytesPbReserve: Buffer.alloc(0),
+                        bytesReserve: Buffer.from([0x08, 0x00, 0x38, 0x00]),
+                        bytesGeneralFlags: Buffer.from([0x9a, 0x01, 0x07, 0xaa, 0x03, 0x04, 0x08, 0x08, 0x12, 0x00]),
+                    }
+                },
+                clientSeq: 0,
+                noNeedCompatMsg: false
+            }
+        })
+        return this.packOidbPacket(0x126E, 100, req, true, false);
+    }
+
+    async packUploadC2CPttReq(peerUin: string, ptt: PacketMsgPttElement): Promise<OidbPacket> {
+        const req = new NapProtoMsg(NTV2RichMediaReq).encode({
+            reqHead: {
+                common: {
+                    requestId: 4,
+                    command: 100
+                },
+                scene: {
+                    requestType: 2,
+                    businessType: 3,
+                    sceneType: 1,
+                    c2C: {
+                        accountType: 2,
+                        targetUid: peerUin
+                    }
+                },
+                client: {
+                    agentType: 2
+                }
+            },
+            upload: {
+                uploadInfo: [
+                    {
+                        fileInfo: {
+                            fileSize: ptt.fileSize,
+                            fileHash: ptt.fileMd5,
+                            fileSha1: ptt.fileSha1,
+                            fileName: `${ptt.fileMd5}.amr`,
+                            type: {
+                                type: 3,
+                                picFormat: 0,
+                                videoFormat: 0,
+                                voiceFormat: 1
+                            },
+                            height: 0,
+                            width: 0,
+                            time: ptt.fileDuration,
+                            original: 0
+                        },
+                        subFileType: 0
+                    }
+                ],
+                tryFastUploadCompleted: true,
+                srvSendMsg: false,
+                clientRandomId: crypto.randomBytes(8).readBigUInt64BE() & BigInt('0x7FFFFFFFFFFFFFFF'),
+                compatQMsgSceneType: 1,
+                extBizInfo: {
+                    pic: {
+                        textSummary: "Nya~",
+                    },
+                    ptt: {
+                        bytesReserve: Buffer.from([0x08, 0x00, 0x38, 0x00]),
+                        bytesGeneralFlags: Buffer.from([0x9a, 0x01, 0x0b, 0xaa, 0x03, 0x08, 0x08, 0x04, 0x12, 0x04, 0x00, 0x00, 0x00, 0x00]),
+                    }
+                },
+                clientSeq: 0,
+                noNeedCompatMsg: false
+            }
+        })
+        return this.packOidbPacket(0x126D, 100, req, true, false);
+    }
+
+    async packUploadGroupFileReq(groupUin: number, file: PacketMsgFileElement): Promise<OidbPacket> {
+        const body = new NapProtoMsg(OidbSvcTrpcTcp0x6D6).encode({
+            file: {
+                groupUin: groupUin,
+                appId: 4,
+                busId: 102,
+                entrance: 6,
+                targetDirectory: '/',  // TODO:
+                fileName: file.fileName,
+                localDirectory: `/${file.fileName}`,
+                fileSize: BigInt(file.fileSize),
+                fileMd5: file.fileMd5,
+                fileSha1: file.fileSha1,
+                fileSha3: Buffer.alloc(0),
+                field15: true
+            }
+        });
+        return this.packOidbPacket(0x6D6, 0, body, true, false);
+    }
+
+    async packUploadC2CFileReq(selfUid: string, peerUid: string, file: PacketMsgFileElement): Promise<OidbPacket> {
+        const body = new NapProtoMsg(OidbSvcTrpcTcp0XE37_1700).encode({
+            command: 1700,
+            seq: 0,
+            upload: {
+                senderUid: selfUid,
+                receiverUid: peerUid,
+                fileSize: file.fileSize,
+                fileName: file.fileName,
+                md510MCheckSum: await computeMd5AndLengthWithLimit(file.filePath, 10 * 1024 * 1024),
+                sha1CheckSum: file.fileSha1,
+                localPath: "/",
+                md5CheckSum: file.fileMd5,
+                sha3CheckSum: Buffer.alloc(0)
+            },
+            businessId: 3,
+            clientType: 1,
+            flagSupportMediaPlatform: 1
+        })
+        return this.packOidbPacket(0xE37, 1700, body, false, false);
+    }
+
+    packOfflineFileDownloadReq(fileUUID: string, fileHash: string, senderUid: string, receiverUid: string): OidbPacket {
+        return this.packOidbPacket(0xE37, 800, new NapProtoMsg(OidbSvcTrpcTcp0XE37_800).encode({
+            subCommand: 800,
+            field2: 0,
+            body: {
+                senderUid: senderUid,
+                receiverUid: receiverUid,
+                fileUuid: fileUUID,
+                fileHash: fileHash,
+            },
+            field101: 3,
+            field102: 1,
+            field200: 1,
+        }), false, false);
+    }
+
+    packGroupFileDownloadReq(groupUin: number, fileUUID: string): OidbPacket {
+        return this.packOidbPacket(0x6D6, 2, new NapProtoMsg(OidbSvcTrpcTcp0x6D6).encode({
                download: {
                    groupUin: groupUin,
                    appId: 7,
                    busId: 102,
                    fileId: fileUUID
                }
-            }), true, false)
-        )
+            }), true, false
+        );
    }

    packC2CFileDownloadReq(selfUid: string, fileUUID: string, fileHash: string): PacketHexStr {
-        return this.toHexStr(
+        return this.packetPacket(
            new NapProtoMsg(OidbSvcTrpcTcp0XE37_1200).encode({
                subCommand: 1200,
                field2: 1,
@@ -319,6 +691,18 @@ export class PacketPacker {
                field200: 1,
                field99999: Buffer.from([0xc0, 0x85, 0x2c, 0x01])
            })
-        )
+        );
+    }
+
+    packGroupSignReq(uin: string, groupCode: string): OidbPacket {
+        return this.packOidbPacket(0XEB7, 1, new NapProtoMsg(OidbSvcTrpcTcp0XEB7).encode(
+            {
+                body: {
+                    uin: uin,
+                    groupUin: groupCode,
+                    version: "9.0.90"
+                }
+            }
+        ), false, false);
    }
 }
--- a/src/core/packet/proto/action/action.ts
+++ b/src/core/packet/proto/action/action.ts
@@ -1,6 +1,6 @@
 import { ScalarType } from "@protobuf-ts/runtime";
 import { ProtoField } from "../NapProto";
-import {ContentHead, MessageBody, MessageControl, RoutingHead} from "@/core/packet/proto/message/message";
+import { ContentHead, MessageBody, MessageControl, RoutingHead } from "@/core/packet/proto/message/message";

 export const FaceRoamRequest = {
    comm: ProtoField(1, () => PlatInfo, true),
--- a/src/core/packet/proto/highway/highway.ts
+++ b/src/core/packet/proto/highway/highway.ts
@@ -1,6 +1,6 @@
-import {ScalarType} from "@protobuf-ts/runtime";
-import {ProtoField} from "../NapProto";
-import {MsgInfo, MsgInfoBody} from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+import { MsgInfo, MsgInfoBody } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";

 export const DataHighwayHead = {
    version: ProtoField(1, ScalarType.UINT32),
@@ -12,7 +12,7 @@ export const DataHighwayHead = {
    dataFlag: ProtoField(7, ScalarType.UINT32),
    commandId: ProtoField(8, ScalarType.UINT32),
    buildVer: ProtoField(9, ScalarType.BYTES, true),
-}
+};

 export const FileUploadExt = {
    unknown1: ProtoField(1, ScalarType.INT32),
@@ -20,7 +20,7 @@ export const FileUploadExt = {
    unknown3: ProtoField(3, ScalarType.INT32),
    entry: ProtoField(100, () => FileUploadEntry),
    unknown200: ProtoField(200, ScalarType.INT32),
-}
+};

 export const FileUploadEntry = {
    busiBuff: ProtoField(100, () => ExcitingBusiInfo),
@@ -28,14 +28,14 @@ export const FileUploadEntry = {
    clientInfo: ProtoField(300, () => ExcitingClientInfo),
    fileNameInfo: ProtoField(400, () => ExcitingFileNameInfo),
    host: ProtoField(500, () => ExcitingHostConfig),
-}
+};

 export const ExcitingBusiInfo = {
    busId: ProtoField(1, ScalarType.INT32),
    senderUin: ProtoField(100, ScalarType.UINT64),
    receiverUin: ProtoField(200, ScalarType.UINT64),
    groupCode: ProtoField(400, ScalarType.UINT64),
-}
+};

 export const ExcitingFileEntry = {
    fileSize: ProtoField(100, ScalarType.UINT64),
@@ -44,7 +44,7 @@ export const ExcitingFileEntry = {
    md5S2: ProtoField(400, ScalarType.BYTES),
    fileId: ProtoField(600, ScalarType.STRING),
    uploadKey: ProtoField(700, ScalarType.BYTES),
-}
+};

 export const ExcitingClientInfo = {
    clientType: ProtoField(100, ScalarType.INT32),
@@ -52,31 +52,31 @@ export const ExcitingClientInfo = {
    terminalType: ProtoField(300, ScalarType.INT32),
    clientVer: ProtoField(400, ScalarType.STRING),
    unknown: ProtoField(600, ScalarType.INT32),
-}
+};

 export const ExcitingFileNameInfo = {
    fileName: ProtoField(100, ScalarType.STRING),
-}
+};

 export const ExcitingHostConfig = {
    hosts: ProtoField(200, () => ExcitingHostInfo, false, true),
-}
+};

 export const ExcitingHostInfo = {
    url: ProtoField(1, () => ExcitingUrlInfo),
    port: ProtoField(2, ScalarType.UINT32),
-}
+};

 export const ExcitingUrlInfo = {
    unknown: ProtoField(1, ScalarType.INT32),
    host: ProtoField(2, ScalarType.STRING),
-}
+};

 export const LoginSigHead = {
    uint32LoginSigType: ProtoField(1, ScalarType.UINT32),
    bytesLoginSig: ProtoField(2, ScalarType.BYTES),
    appId: ProtoField(3, ScalarType.UINT32),
-}
+};

 export const NTV2RichMediaHighwayExt = {
    fileUuid: ProtoField(1, ScalarType.STRING),
@@ -85,25 +85,25 @@ export const NTV2RichMediaHighwayExt = {
    msgInfoBody: ProtoField(6, () => MsgInfoBody, false, true),
    blockSize: ProtoField(10, ScalarType.UINT32),
    hash: ProtoField(11, () => NTHighwayHash),
-}
+};

 export const NTHighwayHash = {
    fileSha1: ProtoField(1, ScalarType.BYTES, false, true),
-}
+};

 export const NTHighwayNetwork = {
    ipv4s: ProtoField(1, () => NTHighwayIPv4, false, true),
-}
+};

 export const NTHighwayIPv4 = {
    domain: ProtoField(1, () => NTHighwayDomain),
    port: ProtoField(2, ScalarType.UINT32),
-}
+};

 export const NTHighwayDomain = {
    isEnable: ProtoField(1, ScalarType.BOOL),
    ip: ProtoField(2, ScalarType.STRING),
-}
+};

 export const ReqDataHighwayHead = {
    msgBaseHead: ProtoField(1, () => DataHighwayHead, true),
@@ -111,7 +111,7 @@ export const ReqDataHighwayHead = {
    bytesReqExtendInfo: ProtoField(3, ScalarType.BYTES, true),
    timestamp: ProtoField(4, ScalarType.UINT64),
    msgLoginSigHead: ProtoField(5, () => LoginSigHead, true),
-}
+};

 export const RespDataHighwayHead = {
    msgBaseHead: ProtoField(1, () => DataHighwayHead, true),
@@ -124,7 +124,7 @@ export const RespDataHighwayHead = {
    timestamp: ProtoField(8, ScalarType.UINT64),
    range: ProtoField(9, ScalarType.UINT64),
    isReset: ProtoField(10, ScalarType.UINT32),
-}
+};

 export const SegHead = {
    serviceId: ProtoField(1, ScalarType.UINT32, true),
@@ -140,7 +140,7 @@ export const SegHead = {
    queryTimes: ProtoField(11, ScalarType.UINT32),
    updateCacheIp: ProtoField(12, ScalarType.UINT32),
    cachePort: ProtoField(13, ScalarType.UINT32, true),
-}
+};

 export const GroupAvatarExtra = {
    type: ProtoField(1, ScalarType.UINT32),
@@ -148,8 +148,8 @@ export const GroupAvatarExtra = {
    field3: ProtoField(3, () => GroupAvatarExtraField3),
    field5: ProtoField(5, ScalarType.UINT32),
    field6: ProtoField(6, ScalarType.UINT32),
-}
+};

 export const GroupAvatarExtraField3 = {
    field1: ProtoField(1, ScalarType.UINT32),
-}
+};
--- a/src/core/packet/proto/message/component.ts
+++ b/src/core/packet/proto/message/component.ts
@@ -113,8 +113,26 @@ export const Permission = {

 export const FileExtra = {
    file: ProtoField(1, () => NotOnlineFile),
+    field6: ProtoField(6, () => PrivateFileExtra),
 };

+export const PrivateFileExtra = {
+    field2: ProtoField(2, () => PrivateFileExtraField2),
+}
+
+export const PrivateFileExtraField2 = {
+    field1: ProtoField(1, ScalarType.UINT32),
+    fileUuid: ProtoField(4, ScalarType.STRING),
+    fileName: ProtoField(5, ScalarType.STRING),
+    field6: ProtoField(6, ScalarType.UINT32),
+    field7: ProtoField(7, ScalarType.BYTES),
+    field8: ProtoField(8, ScalarType.BYTES),
+    timestamp1: ProtoField(9, ScalarType.UINT32),
+    fileHash: ProtoField(14, ScalarType.STRING),
+    selfUid: ProtoField(15, ScalarType.STRING),
+    destUid: ProtoField(16, ScalarType.STRING),
+}
+
 export const GroupFileExtra = {
    field1: ProtoField(1, ScalarType.UINT32),
    fileName: ProtoField(2, ScalarType.STRING),
@@ -132,8 +150,9 @@ export const GroupFileExtraInfo = {
    fileSize: ProtoField(3, ScalarType.UINT64),
    fileName: ProtoField(4, ScalarType.STRING),
    field5: ProtoField(5, ScalarType.UINT32),
-    field7: ProtoField(7, ScalarType.STRING),
-    fileMd5: ProtoField(8, ScalarType.STRING),
+    fileSha: ProtoField(6, ScalarType.BYTES),
+    extInfoString: ProtoField(7, ScalarType.STRING),
+    fileMd5: ProtoField(8, ScalarType.BYTES),
 };

 export const ImageExtraUrl = {
--- a/src/core/packet/proto/message/element.ts
+++ b/src/core/packet/proto/message/element.ts
@@ -1,5 +1,5 @@
-import {ScalarType} from "@protobuf-ts/runtime";
-import {ProtoField} from "../NapProto";
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";

 export const Elem = {
    text: ProtoField(1, () => Text, true),
@@ -118,7 +118,7 @@ export const MarketFace = {

 export const MarketFacePbRes = {
    field8: ProtoField(8, ScalarType.INT32)
-}
+};

 export const CustomFace = {
    guid: ProtoField(1, ScalarType.BYTES),
@@ -315,7 +315,7 @@ export const SrcMsgPbRes = {
    senderUid: ProtoField(6, ScalarType.STRING, true),
    receiverUid: ProtoField(7, ScalarType.STRING, true),
    friendSeq: ProtoField(8, ScalarType.UINT32, true),
-}
+};

 export const LightAppElem = {
    data: ProtoField(1, ScalarType.BYTES),
@@ -358,4 +358,4 @@ export const QSmallFaceExtra = {

 export const MarkdownData = {
    content: ProtoField(1, ScalarType.STRING)
-}
+};
--- a/src/core/packet/proto/oidb/Oidb.0XE37_800.ts
+++ b/src/core/packet/proto/oidb/Oidb.0XE37_800.ts
@@ -0,0 +1,62 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+import {OidbSvcTrpcTcp0XE37_800_1200Metadata} from "@/core/packet/proto/oidb/Oidb.0xE37_1200";
+
+export const OidbSvcTrpcTcp0XE37_800 = {
+    subCommand: ProtoField(1, ScalarType.UINT32),
+    field2: ProtoField(2, ScalarType.INT32),
+    body: ProtoField(10, () => OidbSvcTrpcTcp0XE37_800Body, true),
+    field101: ProtoField(101, ScalarType.INT32),
+    field102: ProtoField(102, ScalarType.INT32),
+    field200: ProtoField(200, ScalarType.INT32)
+};
+
+export const OidbSvcTrpcTcp0XE37_800Body = {
+    senderUid: ProtoField(10, ScalarType.STRING, true),
+    receiverUid: ProtoField(20, ScalarType.STRING, true),
+    fileUuid: ProtoField(30, ScalarType.STRING, true),
+    fileHash: ProtoField(40, ScalarType.STRING, true)
+};
+
+export const OidbSvcTrpcTcp0XE37Response = {
+    command: ProtoField(1, ScalarType.UINT32),
+    seq: ProtoField(2, ScalarType.INT32),
+    upload: ProtoField(19, () => ApplyUploadRespV3, true),
+    businessId: ProtoField(101, ScalarType.INT32),
+    clientType: ProtoField(102, ScalarType.INT32),
+    flagSupportMediaPlatform: ProtoField(200, ScalarType.INT32)
+};
+
+export const ApplyUploadRespV3 = {
+    retCode: ProtoField(10, ScalarType.INT32),
+    retMsg: ProtoField(20, ScalarType.STRING, true),
+    totalSpace: ProtoField(30, ScalarType.INT64),
+    usedSpace: ProtoField(40, ScalarType.INT64),
+    uploadedSize: ProtoField(50, ScalarType.INT64),
+    uploadIp: ProtoField(60, ScalarType.STRING, true),
+    uploadDomain: ProtoField(70, ScalarType.STRING, true),
+    uploadPort: ProtoField(80, ScalarType.UINT32),
+    uuid: ProtoField(90, ScalarType.STRING, true),
+    uploadKey: ProtoField(100, ScalarType.BYTES, true),
+    boolFileExist: ProtoField(110, ScalarType.BOOL),
+    packSize: ProtoField(120, ScalarType.INT32),
+    uploadIpList: ProtoField(130, ScalarType.STRING, false, true), // repeated
+    uploadHttpsPort: ProtoField(140, ScalarType.INT32),
+    uploadHttpsDomain: ProtoField(150, ScalarType.STRING, true),
+    uploadDns: ProtoField(160, ScalarType.STRING, true),
+    uploadLanip: ProtoField(170, ScalarType.STRING, true),
+    fileAddon: ProtoField(200, ScalarType.STRING, true),
+    mediaPlatformUploadKey: ProtoField(220, ScalarType.BYTES, true)
+};
+
+export const OidbSvcTrpcTcp0XE37_800Response = {
+    command: ProtoField(1, ScalarType.UINT32, true),
+    subCommand: ProtoField(2, ScalarType.UINT32, true),
+    body: ProtoField(10, () => OidbSvcTrpcTcp0XE37_800ResponseBody, true),
+    field50: ProtoField(50, ScalarType.UINT32, true),
+};
+
+export const OidbSvcTrpcTcp0XE37_800ResponseBody = {
+    field10: ProtoField(10, ScalarType.UINT32, true),
+    field30: ProtoField(30, () => OidbSvcTrpcTcp0XE37_800_1200Metadata, true),
+}
--- a/src/core/packet/proto/oidb/Oidb.0x9067_202.ts
+++ b/src/core/packet/proto/oidb/Oidb.0x9067_202.ts
@@ -14,6 +14,7 @@ export const OidbSvcTrpcTcp0X9067_202Key = {
 //Rsp
 export const OidbSvcTrpcTcp0X9067_202_RkeyList = {
    rkey: ProtoField(1, ScalarType.STRING),
+    ttl: ProtoField(2, ScalarType.UINT64),
    time: ProtoField(4, ScalarType.UINT32),
    type: ProtoField(5, ScalarType.UINT32),

--- a/src/core/packet/proto/oidb/Oidb.0xE37_1200.ts
+++ b/src/core/packet/proto/oidb/Oidb.0xE37_1200.ts
@@ -30,7 +30,7 @@ export const OidbSvcTrpcTcp0XE37_1200ResponseBody = {
    field10: ProtoField(10, ScalarType.UINT32, true),
    state: ProtoField(20, ScalarType.STRING, true),
    result: ProtoField(30, () => OidbSvcTrpcTcp0XE37_1200Result, true),
-    metadata: ProtoField(40, () => OidbSvcTrpcTcp0XE37_1200Metadata, true),
+    metadata: ProtoField(40, () => OidbSvcTrpcTcp0XE37_800_1200Metadata, true),
 };

 export const OidbSvcTrpcTcp0XE37_1200Result = {
@@ -43,7 +43,7 @@ export const OidbSvcTrpcTcp0XE37_1200Result = {
    extra: ProtoField(120, ScalarType.BYTES, true),
 };

-export const OidbSvcTrpcTcp0XE37_1200Metadata = {
+export const OidbSvcTrpcTcp0XE37_800_1200Metadata = {
    uin: ProtoField(1, ScalarType.UINT32, true),
    field2: ProtoField(2, ScalarType.UINT32, true),
    field3: ProtoField(3, ScalarType.UINT32, true),
--- a/src/core/packet/proto/oidb/Oidb.0xE37_1700.ts
+++ b/src/core/packet/proto/oidb/Oidb.0xE37_1700.ts
@@ -0,0 +1,23 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const OidbSvcTrpcTcp0XE37_1700 = {
+    command: ProtoField(1, ScalarType.UINT32, true),
+    seq: ProtoField(2, ScalarType.INT32, true),
+    upload: ProtoField(19, () => ApplyUploadReqV3, true),
+    businessId: ProtoField(101, ScalarType.INT32, true),
+    clientType: ProtoField(102, ScalarType.INT32, true),
+    flagSupportMediaPlatform: ProtoField(200, ScalarType.INT32, true),
+}
+
+export const ApplyUploadReqV3 = {
+    senderUid: ProtoField(10, ScalarType.STRING, true),
+    receiverUid: ProtoField(20, ScalarType.STRING, true),
+    fileSize: ProtoField(30, ScalarType.UINT32, true),
+    fileName: ProtoField(40, ScalarType.STRING, true),
+    md510MCheckSum: ProtoField(50, ScalarType.BYTES, true),
+    sha1CheckSum: ProtoField(60, ScalarType.BYTES, true),
+    localPath: ProtoField(70, ScalarType.STRING, true),
+    md5CheckSum: ProtoField(110, ScalarType.BYTES, true),
+    sha3CheckSum: ProtoField(120, ScalarType.BYTES, true),
+}
--- a/src/core/packet/proto/oidb/Oidb.0xEB7.ts
+++ b/src/core/packet/proto/oidb/Oidb.0xEB7.ts
@@ -0,0 +1,12 @@
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../NapProto";
+
+export const OidbSvcTrpcTcp0XEB7_Body = {
+    uin: ProtoField(1, ScalarType.STRING),
+    groupUin: ProtoField(2, ScalarType.STRING),
+    version: ProtoField(3, ScalarType.STRING),
+};
+
+export const OidbSvcTrpcTcp0XEB7 = {
+    body: ProtoField(2, () => OidbSvcTrpcTcp0XEB7_Body),
+}
--- a/src/core/packet/proto/oidb/common/Ntv2.RichMediaReq.ts
+++ b/src/core/packet/proto/oidb/common/Ntv2.RichMediaReq.ts
@@ -1,5 +1,5 @@
-import {ScalarType} from "@protobuf-ts/runtime";
-import {ProtoField} from "../../NapProto";
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../../NapProto";

 export const NTV2RichMediaReq = {
    ReqHead: ProtoField(1, () => MultiMediaReqHead),
@@ -160,7 +160,7 @@ export const PicUrlExtInfo = {

 export const VideoExtInfo = {
    VideoCodecFormat: ProtoField(1, ScalarType.UINT32),
-}
+};

 export const ExtBizInfo = {
    Pic: ProtoField(1, () => PicExtBizInfo),
--- a/src/core/packet/proto/oidb/common/Ntv2.RichMediaResp.ts
+++ b/src/core/packet/proto/oidb/common/Ntv2.RichMediaResp.ts
@@ -1,6 +1,6 @@
-import {ScalarType} from "@protobuf-ts/runtime";
-import {ProtoField} from "../../NapProto";
-import {CommonHead, MsgInfo, PicUrlExtInfo, VideoExtInfo} from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";
+import { ScalarType } from "@protobuf-ts/runtime";
+import { ProtoField } from "../../NapProto";
+import { CommonHead, MsgInfo, PicUrlExtInfo, VideoExtInfo } from "@/core/packet/proto/oidb/common/Ntv2.RichMediaReq";

 export const NTV2RichMediaResp = {
    respHead: ProtoField(1, () => MultiMediaRespHead),
@@ -13,20 +13,20 @@ export const NTV2RichMediaResp = {
    uploadKeyRenewal: ProtoField(8, () => UploadKeyRenewalResp),
    downloadSafe: ProtoField(9, () => DownloadSafeResp),
    extension: ProtoField(99, ScalarType.BYTES, true),
-}
+};

 export const MultiMediaRespHead = {
    common: ProtoField(1, () => CommonHead),
    retCode: ProtoField(2, ScalarType.UINT32),
    message: ProtoField(3, ScalarType.STRING),
-}
+};

 export const DownloadResp = {
    rKeyParam: ProtoField(1, ScalarType.STRING),
    rKeyTtlSecond: ProtoField(2, ScalarType.UINT32),
    info: ProtoField(3, () => DownloadInfo),
    rKeyCreateTime: ProtoField(4, ScalarType.UINT32),
-}
+};

 export const DownloadInfo = {
    domain: ProtoField(1, ScalarType.STRING),
@@ -36,7 +36,7 @@ export const DownloadInfo = {
    ipv6s: ProtoField(5, () => IPv6, false, true),
    picUrlExtInfo: ProtoField(6, () => PicUrlExtInfo),
    videoExtInfo: ProtoField(7, () => VideoExtInfo),
-}
+};

 export const IPv4 = {
    outIP: ProtoField(1, ScalarType.UINT32),
@@ -44,7 +44,7 @@ export const IPv4 = {
    inIP: ProtoField(3, ScalarType.UINT32),
    inPort: ProtoField(4, ScalarType.UINT32),
    ipType: ProtoField(5, ScalarType.UINT32),
-}
+};

 export const IPv6 = {
    outIP: ProtoField(1, ScalarType.BYTES),
@@ -52,7 +52,7 @@ export const IPv6 = {
    inIP: ProtoField(3, ScalarType.BYTES),
    inPort: ProtoField(4, ScalarType.UINT32),
    ipType: ProtoField(5, ScalarType.UINT32),
-}
+};

 export const UploadResp = {
    uKey: ProtoField(1, ScalarType.STRING, true),
@@ -64,13 +64,13 @@ export const UploadResp = {
    ext: ProtoField(7, () => RichMediaStorageTransInfo, false, true),
    compatQMsg: ProtoField(8, ScalarType.BYTES),
    subFileInfos: ProtoField(10, () => SubFileInfo, false, true),
-}
+};

 export const RichMediaStorageTransInfo = {
    subType: ProtoField(1, ScalarType.UINT32),
    extType: ProtoField(2, ScalarType.UINT32),
    extValue: ProtoField(3, ScalarType.BYTES),
-}
+};

 export const SubFileInfo = {
    subType: ProtoField(1, ScalarType.UINT32),
@@ -78,32 +78,32 @@ export const SubFileInfo = {
    uKeyTtlSecond: ProtoField(3, ScalarType.UINT32),
    ipv4s: ProtoField(4, () => IPv4, false, true),
    ipv6s: ProtoField(5, () => IPv6, false, true),
-}
+};

 export const DownloadSafeResp = {
-}
+};

 export const UploadKeyRenewalResp = {
    ukey: ProtoField(1, ScalarType.STRING),
    ukeyTtlSec: ProtoField(2, ScalarType.UINT64),
-}
+};

 export const MsgInfoAuthResp = {
    authCode: ProtoField(1, ScalarType.UINT32),
    msg: ProtoField(2, ScalarType.BYTES),
    resultTime: ProtoField(3, ScalarType.UINT64),
-}
+};

 export const UploadCompletedResp = {
    msgSeq: ProtoField(1, ScalarType.UINT64),
-}
+};

 export const DeleteResp = {
-}
+};

 export const DownloadRKeyResp = {
    rKeys: ProtoField(1, () => RKeyInfo, false, true),
-}
+};

 export const RKeyInfo = {
    rkey: ProtoField(1, ScalarType.STRING),
@@ -111,4 +111,4 @@ export const RKeyInfo = {
    storeId: ProtoField(3, ScalarType.UINT32),
    rkeyCreateTime: ProtoField(4, ScalarType.UINT32, true),
    type: ProtoField(5, ScalarType.UINT32, true),
-}
+};
--- a/src/core/packet/session.ts
+++ b/src/core/packet/session.ts
@@ -1,7 +1,7 @@
 import { PacketClient } from "@/core/packet/client";
 import { PacketHighwaySession } from "@/core/packet/highway/session";
 import { LogWrapper } from "@/common/log";
-import {PacketPacker} from "@/core/packet/packer";
+import { PacketPacker } from "@/core/packet/packer";

 export class PacketSession {
    readonly logger: LogWrapper;
--- a/src/core/packet/utils/crypto/hash.ts
+++ b/src/core/packet/utils/crypto/hash.ts
@@ -2,6 +2,7 @@
 import * as crypto from 'crypto';
 import * as stream from 'stream';
 import * as fs from 'fs';
+import {CalculateStreamBytesTransform} from "@/core/packet/utils/crypto/sha1StreamBytesTransform";

 function sha1Stream(readable: stream.Readable) {
    return new Promise((resolve, reject) => {
@@ -10,7 +11,37 @@ function sha1Stream(readable: stream.Readable) {
    }) as Promise<Buffer>;
 }

+function md5Stream(readable: stream.Readable) {
+    return new Promise((resolve, reject) => {
+        readable.on('error', reject);
+        readable.pipe(crypto.createHash('md5').on('error', reject).on('data', resolve));
+    }) as Promise<Buffer>;
+}
+
 export function calculateSha1(filePath: string): Promise<Buffer> {
    const readable = fs.createReadStream(filePath);
    return sha1Stream(readable);
 }
+
+export function computeMd5AndLengthWithLimit(filePath: string, limit?: number): Promise<Buffer> {
+    const readStream = fs.createReadStream(filePath, limit ? { start: 0, end: limit - 1 } : {});
+    return md5Stream(readStream);
+}
+
+export function calculateSha1StreamBytes(filePath: string): Promise<Buffer[]> {
+    return new Promise((resolve, reject) => {
+        const readable = fs.createReadStream(filePath);
+        const calculateStreamBytes = new CalculateStreamBytesTransform();
+        const byteArrayList: Buffer[] = [];
+        calculateStreamBytes.on('data', (chunk: Buffer) => {
+            byteArrayList.push(chunk);
+        });
+        calculateStreamBytes.on('end', () => {
+            resolve(byteArrayList);
+        });
+        calculateStreamBytes.on('error', (err) => {
+            reject(err);
+        });
+        readable.pipe(calculateStreamBytes);
+    });
+}
--- a/src/core/packet/utils/crypto/sha1Stream.test.ts
+++ b/src/core/packet/utils/crypto/sha1Stream.test.ts
@@ -0,0 +1,19 @@
+import crypto from 'crypto';
+import assert from 'assert';
+import { Sha1Stream } from './sha1Stream';
+
+function testSha1Stream() {
+    for (let i = 0; i < 100000; i++) {
+        const randomLength = Math.floor(Math.random() * 1024);
+        const randomData = crypto.randomBytes(randomLength);
+        const sha1Stream = new Sha1Stream();
+        sha1Stream.update(randomData);
+        const hash = sha1Stream.final();
+        const expectedDigest = crypto.createHash('sha1').update(randomData).digest();
+        assert.strictEqual(hash.toString('hex'), expectedDigest.toString('hex'));
+        console.log(`Test ${i + 1}: Passed`);
+    }
+    console.log('All tests passed successfully.');
+}
+
+testSha1Stream();
--- a/src/core/packet/utils/crypto/sha1Stream.ts
+++ b/src/core/packet/utils/crypto/sha1Stream.ts
@@ -0,0 +1,118 @@
+export class Sha1Stream {
+    readonly Sha1BlockSize = 64;
+    readonly Sha1DigestSize = 20;
+    private readonly _padding = Buffer.concat([Buffer.from([0x80]), Buffer.alloc(63)]);
+    private readonly _state = new Uint32Array(5);
+    private readonly _count = new Uint32Array(2);
+    private readonly _buffer = Buffer.allocUnsafe(this.Sha1BlockSize);
+    private readonly _w = new Uint32Array(80);
+
+    constructor() {
+        this.reset();
+    }
+
+    private reset(): void {
+        this._state[0] = 0x67452301;
+        this._state[1] = 0xEFCDAB89;
+        this._state[2] = 0x98BADCFE;
+        this._state[3] = 0x10325476;
+        this._state[4] = 0xC3D2E1F0;
+        this._count[0] = 0;
+        this._count[1] = 0;
+        this._buffer.fill(0);
+    }
+
+    private rotateLeft(v: number, o: number): number {
+        return ((v << o) | (v >>> (32 - o))) >>> 0;
+    }
+
+    private transform(chunk: Buffer, offset: number): void {
+        const w = this._w;
+        const view = new DataView(chunk.buffer, chunk.byteOffset + offset, 64);
+
+        for (let i = 0; i < 16; i++) {
+            w[i] = view.getUint32(i * 4, false);
+        }
+
+        for (let i = 16; i < 80; i++) {
+            w[i] = this.rotateLeft(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1) >>> 0;
+        }
+
+        let a = this._state[0];
+        let b = this._state[1];
+        let c = this._state[2];
+        let d = this._state[3];
+        let e = this._state[4];
+
+        for (let i = 0; i < 80; i++) {
+            const [f, k] = (i < 20) ? [(b & c) | ((~b) & d), 0x5A827999] :
+                (i < 40) ? [b ^ c ^ d, 0x6ED9EBA1] :
+                    (i < 60) ? [(b & c) | (b & d) | (c & d), 0x8F1BBCDC] :
+                        [b ^ c ^ d, 0xCA62C1D6];
+            const temp = (this.rotateLeft(a, 5) + f + k + e + w[i]) >>> 0;
+            e = d;
+            d = c;
+            c = this.rotateLeft(b, 30) >>> 0;
+            b = a;
+            a = temp;
+        }
+
+        this._state[0] = (this._state[0] + a) >>> 0;
+        this._state[1] = (this._state[1] + b) >>> 0;
+        this._state[2] = (this._state[2] + c) >>> 0;
+        this._state[3] = (this._state[3] + d) >>> 0;
+        this._state[4] = (this._state[4] + e) >>> 0;
+    }
+
+    public update(data: Buffer, len?: number): void {
+        let index = ((this._count[0] >>> 3) & 0x3F) >>> 0;
+        const dataLen = len ?? data.length;
+        this._count[0] = (this._count[0] + (dataLen << 3)) >>> 0;
+
+        if (this._count[0] < (dataLen << 3)) this._count[1] = (this._count[1] + 1) >>> 0;
+
+        this._count[1] = (this._count[1] + (dataLen >>> 29)) >>> 0;
+
+        let partLen = (this.Sha1BlockSize - index) >>> 0;
+        let i = 0;
+
+        if (dataLen >= partLen) {
+            data.copy(this._buffer, index, 0, partLen);
+            this.transform(this._buffer, 0);
+            for (i = partLen; (i + this.Sha1BlockSize) <= dataLen; i = (i + this.Sha1BlockSize) >>> 0) {
+                this.transform(data, i);
+            }
+            index = 0;
+        }
+
+        data.copy(this._buffer, index, i, dataLen);
+    }
+
+    public hash(bigEndian: boolean = true): Buffer {
+        const digest = Buffer.allocUnsafe(this.Sha1DigestSize);
+        if (bigEndian) {
+            for (let i = 0; i < 5; i++) digest.writeUInt32BE(this._state[i], i * 4);
+        } else {
+            for (let i = 0; i < 5; i++) digest.writeUInt32LE(this._state[i], i * 4);
+        }
+        return digest;
+    }
+
+    public final(): Buffer {
+        const digest = Buffer.allocUnsafe(this.Sha1DigestSize);
+        const bits = Buffer.allocUnsafe(8)
+        bits.writeUInt32BE(this._count[1], 0);
+        bits.writeUInt32BE(this._count[0], 4);
+
+        let index = ((this._count[0] >>> 3) & 0x3F) >>> 0;
+        const padLen = ((index < 56) ? (56 - index) : (120 - index)) >>> 0;
+        this.update(this._padding, padLen);
+        this.update(bits);
+
+        for (let i = 0; i < 5; i++) {
+            digest.writeUInt32BE(this._state[i], i * 4);
+        }
+
+        return digest;
+    }
+}
--- a/src/core/packet/utils/crypto/sha1StreamBytesTransform.ts
+++ b/src/core/packet/utils/crypto/sha1StreamBytesTransform.ts
@@ -0,0 +1,53 @@
+import * as stream from "node:stream";
+import {Sha1Stream} from "@/core/packet/utils/crypto/sha1Stream";
+
+export class CalculateStreamBytesTransform extends stream.Transform {
+    private readonly blockSize = 1024 * 1024;
+    private sha1: Sha1Stream;
+    private buffer: Buffer;
+    private bytesRead: number;
+    private readonly byteArrayList: Buffer[];
+
+    constructor() {
+        super();
+        this.sha1 = new Sha1Stream();
+        this.buffer = Buffer.alloc(0);
+        this.bytesRead = 0;
+        this.byteArrayList = [];
+    }
+
+    _transform(chunk: Buffer, _: BufferEncoding, callback: stream.TransformCallback): void {
+        try {
+            this.buffer = Buffer.concat([this.buffer, chunk]);
+            let offset = 0;
+            while (this.buffer.length - offset >= this.sha1.Sha1BlockSize) {
+                const block = this.buffer.subarray(offset, offset + this.sha1.Sha1BlockSize);
+                this.sha1.update(block);
+                offset += this.sha1.Sha1BlockSize;
+                this.bytesRead += this.sha1.Sha1BlockSize;
+                if (this.bytesRead % this.blockSize === 0) {
+                    const digest = this.sha1.hash(false);
+                    this.byteArrayList.push(Buffer.from(digest));
+                }
+            }
+            this.buffer = this.buffer.subarray(offset);
+            callback(null);
+        } catch (err) {
+            callback(err as Error);
+        }
+    }
+
+    _flush(callback: stream.TransformCallback): void {
+        try {
+            if (this.buffer.length > 0) this.sha1.update(this.buffer);
+            const finalDigest = this.sha1.final();
+            this.byteArrayList.push(Buffer.from(finalDigest));
+            for (const digest of this.byteArrayList) {
+                this.push(digest);
+            }
+            callback(null);
+        } catch (err) {
+            callback(err as Error);
+        }
+    }
+}
--- a/src/core/packet/utils/crypto/tea.ts
+++ b/src/core/packet/utils/crypto/tea.ts
@@ -76,7 +76,7 @@ export function decrypt(encrypted: Buffer, key: Buffer) {
        encrypted.writeInt32BE(r1, i);
        encrypted.writeInt32BE(r2, i + 4);
    }
-    if (Buffer.compare(encrypted.subarray(encrypted.length - 7), BUF7) !== 0) throw ERROR_ENCRYPTED_ILLEGAL
+    if (Buffer.compare(encrypted.subarray(encrypted.length - 7), BUF7) !== 0) throw ERROR_ENCRYPTED_ILLEGAL;
    // if (Buffer.compare(encrypted.slice(encrypted.length - 7), BUF7) !== 0) throw ERROR_ENCRYPTED_ILLEGAL;
    return encrypted.subarray((encrypted[0] & 0x07) + 3, encrypted.length - 7);
    // return encrypted.slice((encrypted[0] & 0x07) + 3, encrypted.length - 7);
--- a/src/core/services/NodeIKernelBuddyService.ts
+++ b/src/core/services/NodeIKernelBuddyService.ts
@@ -36,7 +36,7 @@ export interface NodeIKernelBuddyService {

    getBuddyRemark(uid: number): string;

-    setBuddyRemark(uid: string, remark: string): void;
+    setBuddyRemark(param: { uid: string, remark: string, signInfo?: unknown }): void;

    getAvatarUrl(uid: number): string;

--- a/src/core/services/NodeIKernelGroupService.ts
+++ b/src/core/services/NodeIKernelGroupService.ts
@@ -239,7 +239,7 @@ export interface NodeIKernelGroupService {

    setMemberShutUp(groupCode: string, memberTimes: { uid: string, timeStamp: number }[]): Promise<void>;

-    getGroupRecommendContactArkJson(groupCode: string): unknown;
+    getGroupRecommendContactArkJson(groupCode: string): Promise<GeneralCallResult & { arkJson: string }>;

    getJoinGroupLink(param: {
        groupCode: string,
--- a/src/onebot/action/extends/GetGroupAddRequest.ts
+++ b/src/onebot/action/extends/GetGroupAddRequest.ts
@@ -1,3 +1,4 @@
+import { GroupNotifyMsgStatus } from '@/core';
 import BaseAction from '../BaseAction';
 import { ActionName } from '../types';

@@ -11,18 +12,22 @@ export default class GetGroupAddRequest extends BaseAction<null, OB11GroupReques
    actionName = ActionName.GetGroupIgnoreAddRequest;

    async _handle(payload: null): Promise<OB11GroupRequestNotify[] | null> {
-        // const data = await this.core.apis.GroupApi.getGroupIgnoreNotifies();
-        // log(data);
-        // const notifies: GroupNotify[] = data.notifies.filter(notify => notify.status === GroupNotifyStatus.WAIT_HANDLE);
-        // const returnData: OB11GroupRequestNotify[] = [];
-        // for (const notify of notifies) {
-        //   const uin = || (await NTQQUserApi.getUserDetailInfo(notify.user1.uid))?.uin;
-        //   returnData.push({
-        //     group_id: parseInt(notify.group.groupCode),
-        //     user_id: parseInt(uin),
-        //     flag: notify.seq
-        //   });
-        // }
-        return null;
+        const ignoredNotifies = await this.core.apis.GroupApi.getSingleScreenNotifies(true, 10);
+        const retData: any = {
+            join_requests: await Promise.all(
+                ignoredNotifies
+                    .filter(notify => notify.type === 7)
+                    .map(async SSNotify => ({
+                        request_id: SSNotify.seq,
+                        requester_uin: await this.core.apis.UserApi.getUinByUidV2(SSNotify.user1?.uid),
+                        requester_nick: SSNotify.user1?.nickName,
+                        group_id: SSNotify.group?.groupCode,
+                        group_name: SSNotify.group?.groupName,
+                        checked: SSNotify.status !== GroupNotifyMsgStatus.KUNHANDLE,
+                        actor: await this.core.apis.UserApi.getUinByUidV2(SSNotify.user2?.uid) || 0,
+                    }))),
+        };
+
+        return retData;
    }
 }
--- a/src/onebot/action/extends/GetUserStatus.ts
+++ b/src/onebot/action/extends/GetUserStatus.ts
@@ -1,6 +1,6 @@
 import { ActionName } from '../types';
 import { FromSchema, JSONSchema } from 'json-schema-to-ts';
-import {GetPacketStatusDepends} from "@/onebot/action/packet/GetPacketStatus";
+import { GetPacketStatusDepends } from "@/onebot/action/packet/GetPacketStatus";
 // no_cache get时传字符串
 const SchemaData = {
    type: 'object',
--- a/src/onebot/action/extends/SetGroupSign.ts
+++ b/src/onebot/action/extends/SetGroupSign.ts
@@ -0,0 +1,22 @@
+import BaseAction from '../BaseAction';
+import { ActionName } from '../types';
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
+
+const SchemaData = {
+    type: 'object',
+    properties: {
+        group_id: { type: 'string' },
+    },
+    required: ['group_id'],
+} as const satisfies JSONSchema;
+
+type Payload = FromSchema<typeof SchemaData>;
+
+export class SetGroupSign extends BaseAction<Payload, any> {
+    actionName = ActionName.SetGroupSign;
+    payloadSchema = SchemaData;
+
+    async _handle(payload: Payload) {
+        return await this.core.apis.PacketApi.sendGroupSignPacket(payload.group_id);
+    }
+}
--- a/src/onebot/action/file/GetFile.ts
+++ b/src/onebot/action/file/GetFile.ts
@@ -5,9 +5,9 @@ import { ActionName } from '../types';
 import { FromSchema, JSONSchema } from 'json-schema-to-ts';
 import { OB11MessageImage, OB11MessageVideo } from '@/onebot/types';

-export interface GetFilePayload {
-    file: string; // 文件名或者fileUuid
-}
+//  interface GetFilePayload {
+//     file: string; // 文件名或者fileUuid
+// }

 export interface GetFileResponse {
    file?: string;  // path
@@ -16,19 +16,25 @@ export interface GetFileResponse {
    file_name?: string;
    base64?: string;
 }
-
 const GetFileBase_PayloadSchema = {
    type: 'object',
    properties: {
        file: { type: 'string' },
+        file_id: { type: 'string' }
    },
-    required: ['file'],
+    oneOf: [
+        { required: ['file'] },
+        { required: ['file_id'] }
+    ]
 } as const satisfies JSONSchema;

+export type GetFilePayload = FromSchema<typeof GetFileBase_PayloadSchema>;
+
 export class GetFileBase extends BaseAction<GetFilePayload, GetFileResponse> {
-    payloadSchema: any = GetFileBase_PayloadSchema;
+    payloadSchema = GetFileBase_PayloadSchema;

    async _handle(payload: GetFilePayload): Promise<GetFileResponse> {
+        payload.file ||= payload.file_id || '';
        //接收消息标记模式
        const contextMsgFile = FileNapCatOneBotUUID.decode(payload.file);
        if (contextMsgFile) {
@@ -115,27 +121,6 @@ export class GetFileBase extends BaseAction<GetFilePayload, GetFileResponse> {
    }
 }

-const GetFile_PayloadSchema = {
-    type: 'object',
-    properties: {
-        file_id: { type: 'string' },
-        file: { type: 'string' },
-    },
-    required: ['file_id'],
-} as const satisfies JSONSchema;
-
-type GetFile_Payload_Internal = FromSchema<typeof GetFile_PayloadSchema>;
-
-interface GetFile_Payload extends GetFile_Payload_Internal {
-    file: string;
-}
-
 export default class GetFile extends GetFileBase {
    actionName = ActionName.GetFile;
-    payloadSchema = GetFile_PayloadSchema;
-
-    async _handle(payload: GetFile_Payload): Promise<GetFileResponse> {
-        payload.file = payload.file_id;
-        return super._handle(payload);
-    }
 }
--- a/src/onebot/action/file/GetGroupFileUrl.ts
+++ b/src/onebot/action/file/GetGroupFileUrl.ts
@@ -27,7 +27,7 @@ export class GetGroupFileUrl extends GetPacketStatusDepends<Payload, GetGroupFil
        if (contextMsgFile?.fileUUID) {
            return {
                url: await this.core.apis.PacketApi.sendGroupFileDownloadReq(+payload.group_id, contextMsgFile.fileUUID)
-            }
+            };
        }
        throw new Error('real fileUUID not found!');
    }
--- a/src/onebot/action/go-cqhttp/GetForwardMsg.ts
+++ b/src/onebot/action/go-cqhttp/GetForwardMsg.ts
@@ -1,5 +1,5 @@
 import BaseAction from '../BaseAction';
-import { OB11Message, OB11MessageData, OB11MessageDataType, OB11MessageForward, OB11MessageNodePlain as OB11MessageNode} from '@/onebot';
+import { OB11Message, OB11MessageData, OB11MessageDataType, OB11MessageForward, OB11MessageNodePlain as OB11MessageNode } from '@/onebot';
 import { ActionName } from '../types';
 import { FromSchema, JSONSchema } from 'json-schema-to-ts';
 import { MessageUnique } from '@/common/message-unique';
--- a/src/onebot/action/group/GroupPoke.ts
+++ b/src/onebot/action/group/GroupPoke.ts
@@ -1,6 +1,6 @@
 import { ActionName } from '../types';
 import { FromSchema, JSONSchema } from 'json-schema-to-ts';
-import {GetPacketStatusDepends} from "@/onebot/action/packet/GetPacketStatus";
+import { GetPacketStatusDepends } from "@/onebot/action/packet/GetPacketStatus";
 // no_cache get时传字符串
 const SchemaData = {
    type: 'object',
@@ -18,6 +18,6 @@ export class GroupPoke extends GetPacketStatusDepends<Payload, any> {
    payloadSchema = SchemaData;

    async _handle(payload: Payload) {
-        await this.core.apis.PacketApi.sendPokePacket(+payload.group_id, +payload.user_id);
+        await this.core.apis.PacketApi.sendPokePacket(+payload.user_id, +payload.group_id);
    }
 }
--- a/src/onebot/action/index.ts
+++ b/src/onebot/action/index.ts
@@ -90,7 +90,10 @@ import { SetSpecialTittle } from './extends/SetSpecialTittle';
 import { GetGroupShutList } from './group/GetGroupShutList';
 import { GetGroupMemberList } from './group/GetGroupMemberList';
 import { GetGroupFileUrl } from "@/onebot/action/file/GetGroupFileUrl";
-import {GetPacketStatus} from "@/onebot/action/packet/GetPacketStatus";
+import { GetPacketStatus } from "@/onebot/action/packet/GetPacketStatus";
+import { FriendPoke } from "@/onebot/action/user/FriendPoke";
+import { GetCredentials } from './system/GetCredentials';
+import { SetGroupSign } from './extends/SetGroupSign';


 export type ActionMap = Map<string, BaseAction<any, any>>;
@@ -113,6 +116,7 @@ export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCo
        new SetQQAvatar(obContext, core),
        new TranslateEnWordToZn(obContext, core),
        new GetGroupRootFiles(obContext, core),
+        new SetGroupSign(obContext, core),
        // onebot11
        new SendLike(obContext, core),
        new GetMsg(obContext, core),
@@ -179,6 +183,7 @@ export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCo
        new SetModelShow(obContext, core),
        new SetInputStatus(obContext, core),
        new GetCSRF(obContext, core),
+        new GetCredentials(obContext, core),
        new DelGroupNotice(obContext, core),
        new DeleteGroupFile(obContext, core),
        new CreateGroupFileFolder(obContext, core),
@@ -189,6 +194,7 @@ export function createActionMap(obContext: NapCatOneBot11Adapter, core: NapCatCo
        new FetchUserProfileLike(obContext, core),
        new GetPacketStatus(obContext, core),
        new GroupPoke(obContext, core),
+        new FriendPoke(obContext, core),
        new GetUserStatus(obContext, core),
        new GetRkey(obContext, core),
        new SetSpecialTittle(obContext, core),
--- a/src/onebot/action/msg/MarkMsgAsRead.ts
+++ b/src/onebot/action/msg/MarkMsgAsRead.ts
@@ -1,7 +1,7 @@
 import { ChatType, Peer } from '@/core/entities';
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
 import BaseAction from '../BaseAction';
 import { ActionName } from '../types';
-import { FromSchema, JSONSchema } from 'json-schema-to-ts';

 const SchemaData = {
    type: 'object',
@@ -49,23 +49,14 @@ export class MarkGroupMsgAsRead extends MarkMsgAsRead {
    actionName = ActionName.MarkGroupMsgAsRead;
 }

-
-interface Payload {
-    message_id: number;
-}
-
-export class GoCQHTTPMarkMsgAsRead extends BaseAction<Payload, null> {
+export class GoCQHTTPMarkMsgAsRead extends MarkMsgAsRead {
    actionName = ActionName.GoCQHTTP_MarkMsgAsRead;
-
-    async _handle(payload: Payload): Promise<null> {
-        return null;
-    }
 }

-export class MarkAllMsgAsRead extends BaseAction<Payload, null> {
+export class MarkAllMsgAsRead extends BaseAction<any, null> {
    actionName = ActionName._MarkAllMsgAsRead;

-    async _handle(payload: Payload): Promise<null> {
+    async _handle(): Promise<null> {
        await this.core.apis.MsgApi.markAllMsgAsRead();
        return null;
    }
--- a/src/onebot/action/msg/SendMsg.ts
+++ b/src/onebot/action/msg/SendMsg.ts
@@ -6,14 +6,14 @@ import {
    OB11PostContext,
    OB11PostSendMsg,
 } from '@/onebot/types';
-import {ActionName, BaseCheckResult} from '@/onebot/action/types';
-import {decodeCQCode} from '@/onebot/cqcode';
-import {MessageUnique} from '@/common/message-unique';
-import {ChatType, ElementType, NapCatCore, Peer, RawMessage, SendArkElement, SendMessageElement} from '@/core';
+import { ActionName, BaseCheckResult } from '@/onebot/action/types';
+import { decodeCQCode } from '@/onebot/cqcode';
+import { MessageUnique } from '@/common/message-unique';
+import { ChatType, ElementType, NapCatCore, Peer, RawMessage, SendArkElement, SendMessageElement } from '@/core';
 import BaseAction from '../BaseAction';
-import {rawMsgWithSendMsg} from "@/core/packet/msg/converter";
-import {PacketMsg} from "@/core/packet/msg/message";
-import {PacketMultiMsgElement} from "@/core/packet/msg/element";
+import { rawMsgWithSendMsg } from "@/core/packet/msg/converter";
+import { PacketMsg } from "@/core/packet/msg/message";
+import { ForwardMsgBuilder } from "@/common/forward-msg-builder";

 export interface ReturnDataType {
    message_id: number;
@@ -30,7 +30,7 @@ export enum ContextMode {
 export function normalize(message: OB11MessageMixType, autoEscape = false): OB11MessageData[] {
    return typeof message === 'string' ? (
        autoEscape ?
-            [{type: OB11MessageDataType.text, data: {text: message}}] :
+            [{ type: OB11MessageDataType.text, data: { text: message } }] :
            decodeCQCode(message)
    ) : Array.isArray(message) ? message : [message];
 }
@@ -100,7 +100,7 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
                message: '转发消息不能和普通消息混在一起发送,转发需要保证message只有type为node的元素',
            };
        }
-        return {valid: true};
+        return { valid: true };
    }

    async _handle(payload: OB11PostSendMsg): Promise<ReturnDataType> {
@@ -115,9 +115,9 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
        );

        if (getSpecialMsgNum(payload, OB11MessageDataType.node)) {
-            const packetMode = this.core.apis.PacketApi.available
+            const packetMode = this.core.apis.PacketApi.available;
            const returnMsgAndResId = packetMode
-                ? await this.handleForwardedNodesPacket(peer, messages as OB11MessageNode[])
+                ? await this.handleForwardedNodesPacket(peer, messages as OB11MessageNode[], payload.source, payload.news, payload.summary, payload.prompt)
                : await this.handleForwardedNodes(peer, messages as OB11MessageNode[]);
            if (returnMsgAndResId.message) {
                const msgShortId = MessageUnique.createUniqueMsgId({
@@ -125,7 +125,9 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
                    peerUid: peer.peerUid,
                    chatType: peer.chatType,
                }, (returnMsgAndResId.message)!.msgId);
-                return {message_id: msgShortId!, res_id: returnMsgAndResId.res_id};
+                return { message_id: msgShortId!, res_id: returnMsgAndResId.res_id };
+            } else if (returnMsgAndResId.res_id && !returnMsgAndResId.message) {
+                throw Error(`发送转发消息（res_id：${returnMsgAndResId.res_id} 失败`);
            }
            throw Error('发送转发消息失败');
        } else {
@@ -137,13 +139,14 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
        }
        // log("send msg:", peer, sendElements)

-        const {sendElements, deleteAfterSentFiles} = await this.obContext.apis.MsgApi
+        const { sendElements, deleteAfterSentFiles } = await this.obContext.apis.MsgApi
            .createSendElements(messages, peer);
        const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(peer, sendElements, deleteAfterSentFiles);
-        return {message_id: returnMsg!.id!};
+        return { message_id: returnMsg!.id! };
    }

-    private async handleForwardedNodesPacket(msgPeer: Peer, messageNodes: OB11MessageNode[]): Promise<{
+    // TODO: recursively handle forwarded nodes
+    private async handleForwardedNodesPacket(msgPeer: Peer, messageNodes: OB11MessageNode[], source?: string, news?: { text: string }[], summary?: string, prompt?: string): Promise<{
        message: RawMessage | null,
        res_id?: string
    }> {
@@ -152,14 +155,14 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
        for (const node of messageNodes) {
            if ((node.data.id && typeof node.data.content !== "string") || !node.data.id) {
                const OB11Data = normalize(node.data.content);
-                const {sendElements} = await this.obContext.apis.MsgApi.createSendElements(OB11Data, msgPeer);
+                const { sendElements } = await this.obContext.apis.MsgApi.createSendElements(OB11Data, msgPeer);
                const packetMsgElements: rawMsgWithSendMsg = {
-                    senderUin: node.data.user_id ?? +this.core.selfInfo.uin,
+                    senderUin: Number(node.data.user_id) ?? +this.core.selfInfo.uin,
                    senderName: node.data.nickname,
                    groupId: msgPeer.chatType === ChatType.KCHATTYPEGROUP ? +msgPeer.peerUid : undefined,
                    time: Date.now(),
                    msg: sendElements,
-                }
+                };
                logger.logDebug(`handleForwardedNodesPacket 开始转换 ${JSON.stringify(packetMsgElements)}`);
                const transformedMsg = this.core.apis.PacketApi.packetSession?.packer.packetConverter.rawMsgWithSendMsgToPacketMsg(packetMsgElements);
                logger.logDebug(`handleForwardedNodesPacket 转换为 ${JSON.stringify(transformedMsg)}`);
@@ -169,23 +172,21 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
            }
        }
        const resid = await this.core.apis.PacketApi.sendUploadForwardMsg(packetMsg, msgPeer.chatType === ChatType.KCHATTYPEGROUP ? +msgPeer.peerUid : 0);
-        const forwardJson = new PacketMultiMsgElement({
-            elementType: ElementType.STRUCTLONGMSG,
-            elementId: "",
-            structLongMsgElement: {
-                xmlContent: "",
-                resId: resid
-            }
-        }, packetMsg).JSON;
+        const forwardJson = ForwardMsgBuilder.fromPacketMsg(resid, packetMsg, source, news, summary, prompt);
        const finallySendElements = {
            elementType: ElementType.ARK,
            elementId: "",
            arkElement: {
                bytesData: JSON.stringify(forwardJson),
            },
-        } as SendArkElement
-        const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(msgPeer, [finallySendElements], [], true).catch(_ => undefined)
-        return {message: returnMsg ?? null, res_id: resid};
+        } as SendArkElement;
+        let returnMsg: RawMessage | undefined;
+        try {
+            returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(msgPeer, [finallySendElements], [], true).catch(_ => undefined);
+        } catch (e) {
+            logger.logWarn("发送伪造合并转发消息失败！", e);
+        }
+        return { message: returnMsg ?? null, res_id: resid };
    }

    private async handleForwardedNodes(destPeer: Peer, messageNodes: OB11MessageNode[]): Promise<{
@@ -227,7 +228,7 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
                        //完成子卡片生成跳过后续
                        continue;
                    }
-                    const {sendElements} = await this.obContext.apis.MsgApi
+                    const { sendElements } = await this.obContext.apis.MsgApi
                        .createSendElements(OB11Data, destPeer);

                    //拆分消息
@@ -268,7 +269,7 @@ export class SendMsg extends BaseAction<OB11PostSendMsg, ReturnDataType> {
                continue;
            }
            const nodeMsg = (await this.core.apis.MsgApi.getMsgsByMsgId(nodeMsgPeer.Peer, [msgId])).msgList[0];
-            srcPeer = srcPeer ?? {chatType: nodeMsg.chatType, peerUid: nodeMsg.peerUid};
+            srcPeer = srcPeer ?? { chatType: nodeMsg.chatType, peerUid: nodeMsg.peerUid };
            if (srcPeer.peerUid !== nodeMsg.peerUid) {
                needSendSelf = true;
            }
--- a/src/onebot/action/packet/GetPacketStatus.ts
+++ b/src/onebot/action/packet/GetPacketStatus.ts
@@ -1,5 +1,5 @@
 import BaseAction from '../BaseAction';
-import {ActionName, BaseCheckResult} from '../types';
+import { ActionName, BaseCheckResult } from '../types';


 export abstract class GetPacketStatusDepends<PT, RT> extends BaseAction<PT, RT> {
@@ -10,16 +10,16 @@ export abstract class GetPacketStatusDepends<PT, RT> extends BaseAction<PT, RT>
            return {
                valid: false,
                message: "packetServer不可用，请参照文档 https://napneko.github.io/config/advanced 检查packetServer状态或进行配置！",
-            }
+            };
        }
        return {
            valid: true,
-        }
+        };
    }
 }

 export class GetPacketStatus extends GetPacketStatusDepends<any, null> {
    async _handle(payload: any) {
-        return null
+        return null;
    }
 }
--- a/src/onebot/action/system/GetCSRF.ts
+++ b/src/onebot/action/system/GetCSRF.ts
@@ -5,8 +5,12 @@ export class GetCSRF extends BaseAction<any, any> {
    actionName = ActionName.GetCSRF;

    async _handle(payload: any) {
+        const sKey = await this.core.apis.UserApi.getSKey();
+        if (!sKey) {
+            throw new Error('SKey is undefined');
+        }
        return {
-            token: '',
+            token: +this.core.apis.WebApi.getBknFromSKey(sKey),
        };
    }
 }
--- a/src/onebot/action/system/GetCredentials.ts
+++ b/src/onebot/action/system/GetCredentials.ts
@@ -0,0 +1,31 @@
+import BaseAction from '../BaseAction';
+import { ActionName } from '../types';
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
+
+interface Response {
+    cookies: string,
+    token: number
+}
+
+const SchemaData = {
+    type: 'object',
+    properties: {
+        domain: { type: 'string' },
+    },
+    required: ['domain'],
+} as const satisfies JSONSchema;
+
+type Payload = FromSchema<typeof SchemaData>;
+
+export class GetCredentials extends BaseAction<Payload, Response> {
+    actionName = ActionName.GetCredentials;
+    payloadSchema = SchemaData;
+
+    async _handle(payload: Payload) {
+        const cookiesObject = await this.core.apis.UserApi.getCookies(payload.domain);
+        //把获取到的cookiesObject转换成 k=v; 格式字符串拼接在一起
+        const cookies = Object.entries(cookiesObject).map(([key, value]) => `${key}=${value}`).join('; ');
+        const bkn = cookiesObject?.skey ? this.core.apis.WebApi.getBknFromCookie(cookiesObject) : '';
+        return { cookies: cookies, token: +bkn };
+    }
+}
--- a/src/onebot/action/types.ts
+++ b/src/onebot/action/types.ts
@@ -1,4 +1,4 @@
-export type BaseCheckResult = ValidCheckResult | InvalidCheckResult
+export type BaseCheckResult = ValidCheckResult | InvalidCheckResult;

 export interface ValidCheckResult {
    valid: true;
@@ -14,117 +14,127 @@ export interface InvalidCheckResult {
 }

 export enum ActionName {
-    // 以下为扩展napcat扩展
-    Unknown = 'unknown',
-    GroupPoke = 'group_poke',
-    SharePeer = 'ArkSharePeer',
-    ShareGroupEx = 'ArkShareGroup',
-    RebootNormal = 'reboot_normal',//无快速登录重新启动
-    GetRobotUinRange = 'get_robot_uin_range',
-    SetOnlineStatus = 'set_online_status',
-    GetFriendsWithCategory = 'get_friends_with_category',
-    GetGroupIgnoreAddRequest = 'get_group_ignore_add_request',
-    SetQQAvatar = 'set_qq_avatar',
-    GetConfig = 'get_config',
-    SetConfig = 'set_config',
-    Debug = 'debug',
-    GetFile = 'get_file',
-    ForwardFriendSingleMsg = 'forward_friend_single_msg',
-    ForwardGroupSingleMsg = 'forward_group_single_msg',
-    TranslateEnWordToZn = 'translate_en2zh',
-    GetGroupFileCount = 'get_group_file_count',
-    GetGroupFileList = 'get_group_file_list',
-    SetGroupFileFolder = 'set_group_file_folder',
-    DelGroupFile = 'del_group_file',
-    DelGroupFileFolder = 'del_group_file_folder',
    // onebot 11
-    Reboot = 'set_restart',
+    SendPrivateMsg = 'send_private_msg',
+    SendGroupMsg = 'send_group_msg',
+    SendMsg = 'send_msg',
+    DeleteMsg = 'delete_msg',
+    GetMsg = 'get_msg',
+    GoCQHTTP_GetForwardMsg = 'get_forward_msg',
    SendLike = 'send_like',
+    SetGroupKick = 'set_group_kick',
+    SetGroupBan = 'set_group_ban',
+    // SetGroupAnoymousBan = 'set_group_anonymous_ban',
+    SetGroupWholeBan = 'set_group_whole_ban',
+    SetGroupAdmin = 'set_group_admin',
+    // SetGroupAnoymous = 'set_group_anonymous',
+    SetGroupCard = 'set_group_card',
+    SetGroupName = 'set_group_name',
+    SetGroupLeave = 'set_group_leave',
+    SetSpecialTittle = 'set_group_special_title',
+    SetFriendAddRequest = 'set_friend_add_request',
+    SetGroupAddRequest = 'set_group_add_request',
    GetLoginInfo = 'get_login_info',
+    GoCQHTTP_GetStrangerInfo = 'get_stranger_info',
    GetFriendList = 'get_friend_list',
    GetGroupInfo = 'get_group_info',
    GetGroupList = 'get_group_list',
    GetGroupMemberInfo = 'get_group_member_info',
    GetGroupMemberList = 'get_group_member_list',
-    GetMsg = 'get_msg',
-    SendMsg = 'send_msg',
-    SendGroupMsg = 'send_group_msg',
-    SendPrivateMsg = 'send_private_msg',
-    DeleteMsg = 'delete_msg',
-    SetMsgEmojiLike = 'set_msg_emoji_like',
-    SetGroupAddRequest = 'set_group_add_request',
-    SetFriendAddRequest = 'set_friend_add_request',
-    SetGroupLeave = 'set_group_leave',
-    GetVersionInfo = 'get_version_info',
-    GetStatus = 'get_status',
-    CanSendRecord = 'can_send_record',
-    CanSendImage = 'can_send_image',
-    SetGroupKick = 'set_group_kick',
-    SetGroupBan = 'set_group_ban',
-    SetGroupWholeBan = 'set_group_whole_ban',
-    SetGroupAdmin = 'set_group_admin',
-    SetGroupCard = 'set_group_card',
-    SetGroupName = 'set_group_name',
-    GetImage = 'get_image',
-    GetRecord = 'get_record',
-    CleanCache = 'clean_cache',
-    GetCookies = 'get_cookies',
-    // 以下为go-cqhttp api
-    GoCQHTTP_HandleQuickAction = '.handle_quick_operation',
    GetGroupHonorInfo = 'get_group_honor_info',
-    GoCQHTTP_GetEssenceMsg = 'get_essence_msg_list',
-    GoCQHTTP_SendGroupNotice = '_send_group_notice',
-    GoCQHTTP_GetGroupNotice = '_get_group_notice',
-    GoCQHTTP_SendForwardMsg = 'send_forward_msg',
+    GetCookies = 'get_cookies',
+    GetCSRF = 'get_csrf_token',
+    GetCredentials = 'get_credentials',
+    GetRecord = 'get_record',
+    GetImage = 'get_image',
+    CanSendImage = 'can_send_image',
+    CanSendRecord = 'can_send_record',
+    GetStatus = 'get_status',
+    GetVersionInfo = 'get_version_info',
+    // Reboot = 'set_restart',
+    // CleanCache = 'clean_cache',
+
+    // go-cqhttp
+    SetQQProfile = 'set_qq_profile',
+    // QidianGetAccountInfo = 'qidian_get_account_info',
+    // GetModelShow = '_get_model_show',
+    // SetModelShow = '_set_model_show',
+    GetOnlineClient = 'get_online_clients',
+    // GetUnidirectionalFriendList = 'get_unidirectional_friend_list',
+    // DeleteFriend = 'delete_friend',
+    // DeleteUnidirectionalFriendList = 'delete_unidirectional_friend',
+    GoCQHTTP_MarkMsgAsRead = 'mark_msg_as_read',
    GoCQHTTP_SendGroupForwardMsg = 'send_group_forward_msg',
    GoCQHTTP_SendPrivateForwardMsg = 'send_private_forward_msg',
-    GoCQHTTP_GetStrangerInfo = 'get_stranger_info',
-    GoCQHTTP_MarkMsgAsRead = 'mark_msg_as_read',
-    GetGuildList = 'get_guild_list',
-    MarkPrivateMsgAsRead = 'mark_private_msg_as_read',
-    MarkGroupMsgAsRead = 'mark_group_msg_as_read',
+    GoCQHTTP_GetGroupMsgHistory = 'get_group_msg_history',
+    OCRImage = 'ocr_image',
+    IOCRImage = '.ocr_image',
+    GetGroupSystemMsg = 'get_group_system_msg',
+    GoCQHTTP_GetEssenceMsg = 'get_essence_msg_list',
+    // GetGroupAtAllRemain = 'get_group_at_all_remain',
+    SetGroupPortrait = 'set_group_portrait',
+    SetEssenceMsg = 'set_essence_msg',
+    DelEssenceMsg = 'delete_essence_msg',
+    GoCQHTTP_SendGroupNotice = '_send_group_notice',
+    GoCQHTTP_GetGroupNotice = '_get_group_notice',
    GoCQHTTP_UploadGroupFile = 'upload_group_file',
    GOCQHTTP_DeleteGroupFile = 'delete_group_file',
-    GOCQHTTP_GetGroupFileUrl = 'get_group_file_url',
    GoCQHTTP_CreateGroupFileFolder = 'create_group_file_folder',
-    GoCQHTTP_DeleteGroupFileFolder = 'delete_group_file_folder',
+    GoCQHTTP_DeleteGroupFileFolder = 'delete_group_folder',
    GoCQHTTP_GetGroupFileSystemInfo = 'get_group_file_system_info',
    GoCQHTTP_GetGroupRootFiles = 'get_group_root_files',
    GoCQHTTP_GetGroupFilesByFolder = 'get_group_files_by_folder',
+    GOCQHTTP_GetGroupFileUrl = 'get_group_file_url',
+    GOCQHTTP_UploadPrivateFile = 'upload_private_file',
+    // GOCQHTTP_ReloadEventFilter = 'reload_event_filter',
    GoCQHTTP_DownloadFile = 'download_file',
-    GoCQHTTP_GetGroupMsgHistory = 'get_group_msg_history',
-    GoCQHTTP_GetForwardMsg = 'get_forward_msg',
+    // GoCQHTTP_CheckUrlSafely = 'check_url_safely',
+    // GoCQHTTP_GetWordSlices = '.get_word_slices',
+    GoCQHTTP_HandleQuickAction = '.handle_quick_operation',
+
+    // 以下为扩展napcat扩展
+    Unknown = 'unknown',
+    SharePeer = 'ArkSharePeer',
+    ShareGroupEx = 'ArkShareGroup',
+    // RebootNormal = 'reboot_normal', //无快速登录重新启动
+    GetRobotUinRange = 'get_robot_uin_range',
+    SetOnlineStatus = 'set_online_status',
+    GetFriendsWithCategory = 'get_friends_with_category',
+    SetQQAvatar = 'set_qq_avatar',
+    GetFile = 'get_file',
+    ForwardFriendSingleMsg = 'forward_friend_single_msg',
+    ForwardGroupSingleMsg = 'forward_group_single_msg',
+    TranslateEnWordToZn = 'translate_en2zh',
+    SetMsgEmojiLike = 'set_msg_emoji_like',
+    GoCQHTTP_SendForwardMsg = 'send_forward_msg',
+    MarkPrivateMsgAsRead = 'mark_private_msg_as_read',
+    MarkGroupMsgAsRead = 'mark_group_msg_as_read',
    GetFriendMsgHistory = 'get_friend_msg_history',
-    GetGroupIgnoredNotifies = 'get_group_ignored_notifies',
-    GetOnlineClient = 'get_online_clients',
-    OCRImage = 'ocr_image',
-    IOCRImage = '.ocr_image',
-    SetQQProfile = 'set_qq_profile',
    CreateCollection = 'create_collection',
    GetCollectionList = 'get_collection_list',
    SetLongNick = 'set_self_longnick',
-    SetEssenceMsg = 'set_essence_msg',
-    DelEssenceMsg = 'delete_essence_msg',
    GetRecentContact = 'get_recent_contact',
    _MarkAllMsgAsRead = '_mark_all_as_read',
    GetProfileLike = 'get_profile_like',
-    SetGroupPortrait = 'set_group_portrait',
    FetchCustomFace = 'fetch_custom_face',
-    GOCQHTTP_UploadPrivateFile = 'upload_private_file',
-    TestApi01 = 'test_api_01',
    FetchEmojiLike = 'fetch_emoji_like',
-    GetGuildProfile = 'get_guild_service_profile',
-    SetModelShow = '_set_model_show',
    SetInputStatus = 'set_input_status',
-    GetCSRF = 'get_csrf_token',
+    GetGroupInfoEx = 'get_group_info_ex',
+    GetGroupIgnoreAddRequest = 'get_group_ignore_add_request',
    DelGroupNotice = '_del_group_notice',
-    GetGroupInfoEx = "get_group_info_ex",
-    GetGroupSystemMsg = 'get_group_system_msg',
-    FetchUserProfileLike = "fetch_user_profile_like",
+    FetchUserProfileLike = 'fetch_user_profile_like',
+    FriendPoke = 'friend_poke',
+    GroupPoke = 'group_poke',
    GetPacketStatus = 'nc_get_packet_status',
-    GetUserStatus = "nc_get_user_status",
-    GetRkey = "nc_get_rkey",
-    SetSpecialTittle = "set_group_special_title",
+    GetUserStatus = 'nc_get_user_status',
+    GetRkey = 'nc_get_rkey',
+    GetGroupShutList = 'get_group_shut_list',
+
+    GetGuildList = 'get_guild_list',
+    GetGuildProfile = 'get_guild_service_profile',
+
+    GetGroupIgnoredNotifies = 'get_group_ignored_notifies',
+    
+    SetGroupSign = "set_group_sign",
    // UploadForwardMsg = "upload_forward_msg",
-    GetGroupShutList = "get_group_shut_list",
 }
--- a/src/onebot/action/user/FriendPoke.ts
+++ b/src/onebot/action/user/FriendPoke.ts
@@ -0,0 +1,22 @@
+import { ActionName } from '../types';
+import { FromSchema, JSONSchema } from 'json-schema-to-ts';
+import { GetPacketStatusDepends } from "@/onebot/action/packet/GetPacketStatus";
+
+const SchemaData = {
+    type: 'object',
+    properties: {
+        user_id: { type: ['number', 'string'] },
+    },
+    required: ['user_id'],
+} as const satisfies JSONSchema;
+
+type Payload = FromSchema<typeof SchemaData>;
+
+export class FriendPoke extends GetPacketStatusDepends<Payload, any> {
+    actionName = ActionName.FriendPoke;
+    payloadSchema = SchemaData;
+
+    async _handle(payload: Payload) {
+        await this.core.apis.PacketApi.sendPokePacket(+payload.user_id);
+    }
+}
--- a/src/onebot/api/msg.ts
+++ b/src/onebot/api/msg.ts
@@ -26,15 +26,16 @@ import {
    OB11MessageFileBase,
    OB11MessageForward,
 } from '@/onebot';
-import {OB11Entities} from '@/onebot/entities';
-import {EventType} from '@/onebot/event/OB11BaseEvent';
-import {encodeCQCode} from '@/onebot/cqcode';
-import {uri2local} from '@/common/file';
-import {RequestUtil} from '@/common/request';
+import { OB11Entities } from '@/onebot/entities';
+import { EventType } from '@/onebot/event/OB11BaseEvent';
+import { encodeCQCode } from '@/onebot/cqcode';
+import { uri2local } from '@/common/file';
+import { RequestUtil } from '@/common/request';
 import fs from 'node:fs';
 import fsPromise from 'node:fs/promises';
-import {OB11FriendAddNoticeEvent} from '@/onebot/event/notice/OB11FriendAddNoticeEvent';
-import {decodeSysMessage} from '@/core/packet/proto/old/ProfileLike';
+import { OB11FriendAddNoticeEvent } from '@/onebot/event/notice/OB11FriendAddNoticeEvent';
+import { decodeSysMessage } from '@/core/packet/proto/old/ProfileLike';
+import { ForwardMsgBuilder } from "@/common/forward-msg-builder";

 type RawToOb11Converters = {
    [Key in keyof MessageElement as Key extends `${string}Element` ? Key : never]: (
@@ -600,7 +601,13 @@ export class OneBotMsgApi {

        [OB11MessageDataType.node]: async () => undefined,

-        [OB11MessageDataType.forward]: async () => undefined,
+        [OB11MessageDataType.forward]: async ({ data }, context) => {
+            const jsonData = ForwardMsgBuilder.fromResId(data.id);
+            return this.ob11ToRawConverters.json({
+                data: { data: JSON.stringify(jsonData) },
+                type: OB11MessageDataType.json
+            }, context);
+        },

        [OB11MessageDataType.xml]: async () => undefined,

@@ -617,12 +624,20 @@ export class OneBotMsgApi {

        [OB11MessageDataType.miniapp]: async () => undefined,

-        [OB11MessageDataType.contact]: async ({ data }, context) => {
-            const arkJson = await this.core.apis.UserApi.getBuddyRecommendContactArkJson(data.id.toString(), '');
-            return this.ob11ToRawConverters.json({
-                data: { data: arkJson.arkMsg },
-                type: OB11MessageDataType.json
-            }, context);
+        [OB11MessageDataType.contact]: async ({ data: { type = "qq", id } }, context) => {
+            if(type === "qq"){
+                const arkJson = await this.core.apis.UserApi.getBuddyRecommendContactArkJson(id.toString(), '');
+                return this.ob11ToRawConverters.json({
+                    data: { data: arkJson.arkMsg },
+                    type: OB11MessageDataType.json
+                }, context);
+            }else if(type === "group"){
+                const arkJson = await this.core.apis.GroupApi.getGroupRecommendContactArkJson(id.toString());
+                return this.ob11ToRawConverters.json({
+                    data: { data: arkJson.arkJson },
+                    type: OB11MessageDataType.json
+                }, context);
+            }
        }
    };

--- a/src/onebot/index.ts
+++ b/src/onebot/index.ts
@@ -6,6 +6,7 @@ import {
    GroupNotifyMsgStatus,
    GroupNotifyMsgType,
    InstanceContext,
+    MsgSourceType,
    NapCatCore,
    NodeIKernelBuddyListener,
    NodeIKernelGroupListener,
@@ -303,8 +304,10 @@ export class NapCatOneBot11Adapter {
                    },
                    m.msgId,
                );
+                // if (m.sourceType == MsgSourceType.K_DOWN_SOURCETYPE_AIOINNER) {
                await this.emitMsg(m)
                    .catch(e => this.context.logger.logError.bind(this.context.logger)('处理消息失败', e));
+                // }
            }
        };

--- a/src/onebot/types/message.ts
+++ b/src/onebot/types/message.ts
@@ -16,8 +16,8 @@ export interface OB11Message {
    message_id: number,
    message_seq: number, // 和message_id一样
    real_id: number,
-    user_id: number,
-    group_id?: number,
+    user_id: number | string, // number
+    group_id?: number | string, // number
    message_type: 'private' | 'group',
    sub_type?: 'friend' | 'group' | 'normal',
    sender: OB11Sender,
@@ -85,6 +85,7 @@ export interface OB11MessageText {
 export interface OB11MessageContext {
    type: OB11MessageDataType.contact,
    data: {
+        type:"qq"|"group",
        id: string,
    }
 }
@@ -148,7 +149,7 @@ export interface OB11MessageNode {
    type: OB11MessageDataType.node;
    data: {
        id?: string
-        user_id?: number
+        user_id?: number | string  // number
        nickname: string
        content: OB11MessageMixType
    };
@@ -220,6 +221,10 @@ export interface OB11PostSendMsg {
    message: OB11MessageMixType;
    messages?: OB11MessageMixType;  // 兼容 go-cqhttp
    auto_escape?: boolean | string
+    source?: string,
+    news?: { text: string }[],
+    summary?: string,
+    prompt?: string
 }
 export interface OB11PostContext {
    message_type?: 'private' | 'group'
--- a/src/webui/ui/NapCat.ts
+++ b/src/webui/ui/NapCat.ts
@@ -30,7 +30,7 @@ async function onSettingWindowCreated(view: Element) {
                SettingItem(
                    '<span id="napcat-update-title">Napcat</span>',
                    undefined,
-                    SettingButton('V3.0.1', 'napcat-update-button', 'secondary'),
+                    SettingButton('V3.1.6', 'napcat-update-button', 'secondary'),
                ),
            ]),
            SettingList([
--- a/static/assets/renderer.js
+++ b/static/assets/renderer.js
@@ -164,7 +164,7 @@ async function onSettingWindowCreated(view) {
        SettingItem(
          '<span id="napcat-update-title">Napcat</span>',
          void 0,
-          SettingButton("V3.0.1", "napcat-update-button", "secondary")
+          SettingButton("V3.1.6", "napcat-update-button", "secondary")
        )
      ]),
      SettingList([
Author	SHA1	Message	Date
手瓜一十雪	470c8d0b29	release: v3.1.6	2024-10-25 17:44:30 +08:00
Wesley F. Young	b0d35e803b	update: bump express version to 5.0.0 (Why use beta.2?)	2024-10-25 09:59:02 +08:00
pk5ls20	a71475be8b	feat: allow pass string user_id in `handleForwardedNodesPacket`	2024-10-25 09:17:16 +08:00
pk5ls20	b9f2cc5142	feat: reject >100MB video highway upload	2024-10-25 08:59:56 +08:00
pk5ls20	2d46e55b9b	feat: better highway upload log	2024-10-25 08:54:18 +08:00
pk5ls20	684e254996	feat: make PacketMsgPttElement invalid	2024-10-25 08:33:26 +08:00
手瓜一十雪	a2f7903960	Merge pull request #460 from NapNeko/feat/packet-more feat: support more element in proto	2024-10-25 08:26:52 +08:00
pk5ls20	c0c757d6bd	Merge branch 'main' into feat/packet-more	2024-10-25 08:17:28 +08:00
pk5ls20	da0fad743d	feat: maybe more stable fake forwardMsg	2024-10-25 08:09:17 +08:00
手瓜一十雪	80b10d6025	Merge pull request #463 from clansty/feat/custom-forward-display feat: 自定义合并转发外显信息	2024-10-25 08:05:41 +08:00
pk5ls20	a27c2a69c4	feat: maybe more stable fake forwardMsg	2024-10-25 07:27:35 +08:00
pk5ls20	9ed2a2fd19	refactor: simplify oidb packet pack & send	2024-10-25 06:48:01 +08:00
pk5ls20	aa9d96718c	refactor: outer calculation	2024-10-25 05:54:46 +08:00
pk5ls20	aa67a2b71c	chore: cv多了（	2024-10-25 05:17:01 +08:00
pk5ls20	d3405edd42	refactor: packet highway & etc, kill some todo	2024-10-25 05:11:10 +08:00
Clansty	3612098d62	feat: 自定义合并转发外显信息	2024-10-25 02:42:50 +08:00
手瓜一十雪	ab66904c1a	feat: 3.2.13-28971-arm64	2024-10-24 21:57:54 +08:00
手瓜一十雪	55542a3dbe	feat: 28971 Linux	2024-10-24 20:40:58 +08:00
手瓜一十雪	8569a45114	release: v3.1.5	2024-10-24 20:16:12 +08:00
手瓜一十雪	c790311fc3	release: v3.1.5	2024-10-24 20:11:39 +08:00
手瓜一十雪	3c45c8bd80	feat: 28971	2024-10-24 20:11:07 +08:00
手瓜一十雪	d5b7b3ae31	feat: ntappid	2024-10-24 17:55:33 +08:00
手瓜一十雪	43e73a5f24	doc: big Logo	2024-10-24 17:03:23 +08:00
手瓜一十雪	698947ed97	Merge branch 'main' into feat/packet-more	2024-10-24 14:00:17 +08:00
手瓜一十雪	f3d967ae07	release: 3.1.4	2024-10-24 13:39:05 +08:00
手瓜一十雪	dbe72fa07e	feat: SetGroupSign	2024-10-24 13:38:22 +08:00
pk5ls20	801a97d85b	chore: remove useless log	2024-10-24 04:58:53 +08:00
pk5ls20	9f8f938c47	feat: build & upload file	2024-10-24 04:53:41 +08:00
Wesley F. Young	8fe37d1c1e	chore: reformat `package.json`	2024-10-23 17:54:12 +08:00
pk5ls20	5cca8457e7	chore: 有笨蛋	2024-10-23 16:33:05 +08:00
pk5ls20	e9332e7646	feat: add ptt msg pack & upload	2024-10-23 16:12:31 +08:00
手瓜一十雪	31365505d8	Merge pull request #461 from huankong233/main 优化 contact 支持群聊和私聊	2024-10-23 09:09:07 +08:00
huankong233	b3fbe9e34a	优化 contact 支持群聊和私聊	2024-10-23 09:05:45 +08:00
pk5ls20	4082b651c5	feat & fix: add video msg pack & upload, fix some bugs in uploading c2c elements	2024-10-23 06:14:48 +08:00
手瓜一十雪	5190b26399	Merge pull request #457 from huankong233/main 删除一些过时的接口	2024-10-22 17:57:04 +08:00
手瓜一十雪	29a8db96f4	fix	2024-10-22 17:56:51 +08:00
huankong233	1a4c2cabfd	删除一些过时的接口	2024-10-22 16:45:52 +08:00
手瓜一十雪	ef9189055c	release: 3.1.3	2024-10-22 12:43:54 +08:00
手瓜一十雪	5cc3719125	fix: rkey	2024-10-22 12:42:24 +08:00
手瓜一十雪	5d46f41348	fix: dep	2024-10-22 12:14:43 +08:00
手瓜一十雪	3c2c1963f4	release: 3.1.2	2024-10-22 12:11:02 +08:00
手瓜一十雪	4896ca9279	fix	2024-10-22 11:37:01 +08:00
手瓜一十雪	f0afba6cd9	fix: GetOnlineClient	2024-10-22 11:34:28 +08:00
手瓜一十雪	bd717c298a	fix: get_online_clients	2024-10-22 11:17:39 +08:00
手瓜一十雪	baaa8a70dc	release: 3.1.1	2024-10-22 11:08:24 +08:00
手瓜一十雪	6d561c6e6f	Merge branch 'main' of https://github.com/NapNeko/NapCatQQ	2024-10-22 11:04:43 +08:00
手瓜一十雪	e6b6947d49	feat: 标准化凭据获取	2024-10-22 11:04:28 +08:00
手瓜一十雪	52e99a2175	Merge pull request #454 from huankong233/main 简单修复一些小问题	2024-10-22 10:17:08 +08:00
手瓜一十雪	052d17a46f	fix: getfile	2024-10-22 10:15:16 +08:00
huankong233	1aa1f4c212	优化 getFile 处理逻辑	2024-10-22 09:48:55 +08:00
huankong233	c3a48e3344	修复标记好友/群聊信息已读逻辑	2024-10-21 19:51:17 +08:00
手瓜一十雪	1d5483dc28	Merge pull request #451 from huankong233/main 对接口顺序和文档同步	2024-10-21 16:47:46 +08:00
huankong233	54277fa0df	CleanCache 未实现	2024-10-21 16:09:27 +08:00
huankong233	ab04bd262f	对接口顺序和文档同步	2024-10-21 15:49:57 +08:00
手瓜一十雪	fb23087b65	release: 3.1.0	2024-10-21 14:35:57 +08:00
手瓜一十雪	846fee7ac8	fix: error import	2024-10-21 14:33:12 +08:00
手瓜一十雪	977eacc679	try: fix arm64	2024-10-21 14:12:10 +08:00
手瓜一十雪	dacfefe644	style: lint	2024-10-21 10:17:31 +08:00
pk5ls20	345e941e11	chore: remove unnecessary comments	2024-10-21 04:10:53 +08:00
pk5ls20	6cb7d45464	feat & refactor: decouple the `forwardMsg` construction logic and implement the OB11 element conversion for the forward node.	2024-10-21 04:05:02 +08:00
pk5ls20	e7222653fa	release: 3.0.6	2024-10-20 23:54:21 +08:00
pk5ls20	014f0758f5	chore: 部分回滚 https://github.com/NapNeko/NapCatQQ/commit/bb72d70b	2024-10-20 23:52:36 +08:00
pk5ls20	0e8b416f6d	Merge pull request #448 from pk5ls20/feat/friend-poke feat: add `friend_poke` OneBot11 API	2024-10-20 23:18:26 +08:00
pk5ls20	09a60a2204	feat: add `friend_poke` OneBot11 API	2024-10-20 23:09:38 +08:00
手瓜一十雪	b0eae307c2	release: 3.0.5	2024-10-20 22:18:57 +08:00
手瓜一十雪	f5d2b54cca	fix: 兼容晚启动	2024-10-20 22:18:34 +08:00
手瓜一十雪	3eefec3899	release: v3.0.4	2024-10-20 19:52:23 +08:00
手瓜一十雪	b6a8094554	release: v3.0.3	2024-10-20 18:56:52 +08:00
Version	4083b35436	chore:version change	2024-10-20 10:55:12 +00:00
手瓜一十雪	bb72d70baf	fix: #444 尝试修复	2024-10-20 18:52:18 +08:00
手瓜一十雪	95d1a77f52	fix: remark	2024-10-20 18:30:14 +08:00
手瓜一十雪	051729886e	fix	2024-10-20 17:16:05 +08:00
手瓜一十雪	0f00123dc7	fix	2024-10-20 17:01:09 +08:00