refactor: auto judge client

src/core/packet/client/client.ts

@@ -30,10 +30,6 @@ export abstract class PacketClient {
         this.config = core.configLoader.configData;
     }
 
-    get available(): boolean {
-        return this.isAvailable;
-    }
-
     private randText(len: number): string {
         let text = '';
         const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -43,13 +39,11 @@ export abstract class PacketClient {
         return text;
     }
 
-    static create(core: NapCatCore): PacketClient {
-        throw new Error("Must be implemented by subclasses");
+    get available(): boolean {
+        return this.isAvailable;
     }
 
-    static compatibilityScore(logger: LogWrapper): number {
-        throw new Error("Must be implemented by subclasses");
-    }
+    abstract check(core: NapCatCore): boolean;
 
     abstract init(pid: number, recv: string, send: string): Promise<void>;
 

src/core/packet/client/nativeClient.ts

@@ -5,7 +5,6 @@ import { fileURLToPath } from "url";
 import fs from "fs";
 import { PacketClient } from "@/core/packet/client/client";
 import { constants } from "node:os";
-import { LogWrapper } from "@/common/log";
 import { LRUCache } from "@/common/lru-cache";
 //0 send 1recv
 export interface NativePacketExportType {
@@ -13,10 +12,10 @@ export interface NativePacketExportType {
     SendPacket?: (cmd: string, data: string, trace_id: string) => void;
 }
 export class NativePacketClient extends PacketClient {
-    static supportedPlatforms = ['win32.x64'];
+    private readonly supportedPlatforms = ['win32.x64'];
     private MoeHooExport: { exports: NativePacketExportType } = { exports: {} };
     private sendEvent = new LRUCache<number, string>(500);//seq->trace_id
-    protected constructor(core: NapCatCore) {
+    constructor(core: NapCatCore) {
         super(core);
     }
 
@@ -24,22 +23,18 @@ export class NativePacketClient extends PacketClient {
         return this.isAvailable;
     }
 
-    static compatibilityScore(logger: LogWrapper): number {
+    check(): boolean {
         const platform = process.platform + '.' + process.arch;
         if (!this.supportedPlatforms.includes(platform)) {
-            logger.logError(`[Core] [Packet:Native] 不支持的平台: ${platform}`);
-            return 0;
+            this.logger.logWarn(`[Core] [Packet:Native] 不支持的平台: ${platform}`);
+            return false;
         }
         const moehoo_path = path.join(dirname(fileURLToPath(import.meta.url)), './moehoo/MoeHoo.' + platform + '.node');
         if (!fs.existsSync(moehoo_path)) {
-            logger.logError(`[Core] [Packet:Native] 缺失运行时文件: ${moehoo_path}`);
-            return 0;
+            this.logger.logWarn(`[Core] [Packet:Native] 缺失运行时文件: ${moehoo_path}`);
+            return false;
         }
-        return 10;
-    }
-
-    static create(core: NapCatCore): NativePacketClient {
-        return new NativePacketClient(core);
+        return true;
     }
 
     async init(pid: number, recv: string, send: string): Promise<void> {

src/core/packet/client/wsClient.ts

@@ -1,32 +1,31 @@
 import { Data, WebSocket } from "ws";
 import { NapCatCore } from "@/core";
 import { PacketClient, RecvPacket } from "@/core/packet/client/client";
-import { LogWrapper } from "@/common/log";
 
 export class wsPacketClient extends PacketClient {
     private websocket: WebSocket | undefined;
     private reconnectAttempts: number = 0;
     private readonly maxReconnectAttempts: number = 60; // 现在暂时不可配置
-    private readonly clientUrl: string = '';
+    private readonly clientUrl: string | null = null;
     private clientUrlWrap: (url: string) => string = (url: string) => `ws://${url}/ws`;
 
-    protected constructor(core: NapCatCore) {
+    constructor(core: NapCatCore) {
         super(core);
-        this.clientUrl = this.clientUrlWrap(this.config.packetServer ?? '127.0.0.1:8086');
+        this.clientUrl = this.config.packetServer ? this.clientUrlWrap( this.config.packetServer) : null;
     }
 
-    static compatibilityScore(logger: LogWrapper): number  {
-        return 10;
-    }
-
-    static create(core: NapCatCore): wsPacketClient {
-        return new wsPacketClient(core);
+    check(): boolean {
+        if (!this.clientUrl) {
+            this.logger.logWarn(`[Core] [Packet:Server] 未配置服务器地址`);
+            return false;
+        }
+        return true;
     }
 
     connect(cb: () => void): 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 = new WebSocket(this.clientUrl!);
             this.websocket.on('error', (err) => { }/*this.logger.logError.bind(this.logger)('[Core] [Packet Server] Error:', err.message)*/);
 
             this.websocket.onopen = () => {

src/core/packet/session.ts

@@ -7,12 +7,12 @@ import { wsPacketClient } from "@/core/packet/client/wsClient";
 import { NapCatCore } from "@/core";
 
 type clientPriority = {
-    [key: number]: typeof PacketClient;
+    [key: number]: (core: NapCatCore) => PacketClient;
 }
 
 const clientPriority: clientPriority = {
-    10: NativePacketClient,
-    1: wsPacketClient,
+    10: (core: NapCatCore) => new NativePacketClient(core),
+    1: (core: NapCatCore) => new wsPacketClient(core),
 };
 
 export class PacketSession {
@@ -29,21 +29,19 @@ export class PacketSession {
     }
 
     private judgeClient(core: NapCatCore): PacketClient {
-        let selectedClient: typeof PacketClient | null = null;
-        let maxScore = -1;
-        for (const key in clientPriority) {
-            const priority = parseInt(key);
-            const ClientClass = clientPriority[priority];
-            const score = priority * ClientClass.compatibilityScore(core.context.logger);
-            if (score > maxScore) {
-                maxScore = score;
-                selectedClient = ClientClass;
-            }
-        }
+        const sortedClients = Object.entries(clientPriority)
+            .map(([priority, clientFactory]) => {
+                const client = clientFactory(core);
+                const score = +priority * +client.check(core);
+                return { client, score };
+            })
+            .filter(({ score }) => score > 0)
+            .sort((a, b) => b.score - a.score);
+        const selectedClient = sortedClients[0]?.client;
         if (!selectedClient) {
             throw new Error("[Core] [Packet] 无可用的后端，NapCat.Packet将不会加载！");
         }
-        this.logger.log(`[Core] [Packet] 自动选择 ${selectedClient.name} 作为后端`);
-        return selectedClient.create(core);
+        this.logger.log(`[Core] [Packet] 自动选择 ${selectedClient.constructor.name} 作为后端`);
+        return selectedClient;
     }
 }