feat: update type define in packet

src/core/apis/group.ts

@@ -13,16 +13,6 @@ import {isNumeric, solveAsyncProblem} from '@/common/helper';
 import {LimitedHashTable} from '@/common/message-unique';
 import {NTEventWrapper} from '@/common/event';
 
-interface recvPacket {
-    type: string,//仅recv
-    trace_id_md5?: string,
-    data: {
-        seq: number,
-        hex_data: string,
-        cmd: string
-    }
-}
-
 export class NTQQGroupApi {
     context: InstanceContext;
     core: NapCatCore;

src/core/apis/packet.ts

@@ -2,8 +2,8 @@ import * as os from 'os';
 import * as crypto from 'crypto';
 import {InstanceContext, NapCatCore} from '..';
 import offset from '@/core/external/offset.json';
-import {PacketClient} from '@/core/packet/packetClient';
+import {PacketClient, RecvPacketData} from '@/core/packet/client';
-import {PacketHexStr, PacketPacker} from "@/core/packet/packetPacker";
+import {PacketHexStr, PacketPacker} 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';
@@ -65,12 +65,12 @@ export class NTQQPacketApi {
         return text;
     }
 
-    async sendPacket(cmd: string, data: PacketHexStr, rsp = false): Promise<any> {
+    async sendPacket(cmd: string, data: PacketHexStr, rsp = false): Promise<RecvPacketData> {
         // wtfk tx
         // 校验失败和异常 可能返回undefined
         return new Promise((resolve, reject) => {
             if (!this.isInit || !this.packetClient?.available) {
-                this.core.context.logger.logError('packetClient is not init');
+                this.core.context.logger.logError('PacketClient is not init');
                 return undefined;
             }
             let md5 = crypto.createHash('md5').update(data).digest('hex');

src/core/packet/client.ts

@@ -1,14 +1,26 @@
 import {LogWrapper} from "@/common/log";
 import {LRUCache} from "@/common/lru-cache";
-import WebSocket from "ws";
+import WebSocket, {Data} from "ws";
 import {createHash} from "crypto";
 
+export interface RecvPacket {
+    type: string, // 仅recv
+    trace_id_md5?: string,
+    data: RecvPacketData
+}
+
+export interface RecvPacketData {
+    seq: number
+    cmd: string
+    hex_data: string
+}
+
 export class PacketClient {
     private websocket: WebSocket | undefined;
     private isConnected: boolean = false;
     private reconnectAttempts: number = 0;
     private maxReconnectAttempts: number = 5;
-    private cb = new LRUCache<string, any>(500); // trace_id-type callback
+    private cb = new LRUCache<string, (json: RecvPacketData) => Promise<void>>(500); // trace_id-type callback
     private readonly clientUrl: string = '';
     private readonly logger: LogWrapper;
 
@@ -71,7 +83,7 @@ export class PacketClient {
         }
     }
 
-    async registerCallback(trace_id: string, type: string, callback: any): Promise<void> {
+    async registerCallback(trace_id: string, type: string, callback: (json: RecvPacketData) => Promise<void>): Promise<void> {
         this.cb.put(createHash('md5').update(trace_id).digest('hex') + type, callback);
     }
 
@@ -89,9 +101,9 @@ export class PacketClient {
         this.websocket.send(JSON.stringify(initMessage));
     }
 
-    async sendCommand(cmd: string, data: string, trace_id: string, rsp: boolean = false, timeout: number = 5000, sendcb: any = () => {
+    async sendCommand(cmd: string, data: string, trace_id: string, rsp: boolean = false, timeout: number = 5000, sendcb: (json: RecvPacketData) => void = () => {
-    }): Promise<any> {
+    }): Promise<RecvPacketData> {
-        return new Promise<any>((resolve, reject) => {
+        return new Promise<RecvPacketData>((resolve, reject) => {
             if (!this.isConnected || !this.websocket) {
                 throw new Error("WebSocket is not connected");
             }
@@ -103,12 +115,12 @@ export class PacketClient {
             };
             this.websocket.send(JSON.stringify(commandMessage));
             if (rsp) {
-                this.registerCallback(trace_id, 'recv', (json: any) => {
+                this.registerCallback(trace_id, 'recv', async (json: RecvPacketData) => {
                     clearTimeout(timeoutHandle);
                     resolve(json);
                 });
             }
-            this.registerCallback(trace_id, 'send', (json: any) => {
+            this.registerCallback(trace_id, 'send', async (json: RecvPacketData) => {
                 sendcb(json);
                 if (!rsp) {
                     clearTimeout(timeoutHandle);
@@ -121,9 +133,9 @@ export class PacketClient {
         });
     }
 
-    private async handleMessage(message: any): Promise<void> {
+    private async handleMessage(message: Data): Promise<void> {
         try {
-            let json = JSON.parse(message.toString());
+            let json: RecvPacket = JSON.parse(message.toString());
             let trace_id_md5 = json.trace_id_md5;
             let action = json?.type ?? 'init';
             let event = this.cb.get(trace_id_md5 + action);

src/onebot/action/extends/GetUserStatus.ts

@@ -18,7 +18,7 @@ export class GetUserStatus extends BaseAction<Payload, { status: number; ext_sta
 
     async _handle(payload: Payload) {
         if (!this.core.apis.PacketApi.packetClient?.available) {
-            throw new Error('packetClient is not init');
+            throw new Error('PacketClient is not init');
         }
         return await this.core.apis.PacketApi.sendStatusPacket(+payload.user_id);
     }

src/onebot/action/group/GroupPoke.ts

@@ -19,7 +19,7 @@ export class GroupPoke extends BaseAction<Payload, any> {
 
     async _handle(payload: Payload) {
         if (!this.core.apis.PacketApi.packetClient?.available) {
-            throw new Error('packetClient is not init');
+            throw new Error('PacketClient is not init');
         }
         await this.core.apis.PacketApi.sendPokePacket(+payload.group_id, +payload.user_id);
     }