chore: run a full eslint

2026-02-12 16:00:27 +00:00 · 2024-08-10 19:58:31 +08:00
parent 5a5257294b
commit 87c3b24488
198 changed files with 8187 additions and 7744 deletions
--- a/src/common/framework/event-legacy.ts
+++ b/src/common/framework/event-legacy.ts
@@ -1,5 +1,5 @@
-import { NodeIQQNTWrapperSession } from "@/core/wrapper/wrapper";
-import { randomUUID } from "crypto";
+import { NodeIQQNTWrapperSession } from '@/core/wrapper/wrapper';
+import { randomUUID } from 'crypto';

 interface Internal_MapKey {
    timeout: number;
@@ -23,7 +23,7 @@ export class LegacyNTEventWrapper {

    constructor(
        listenerMapping: Record<string, ListenerIBase>,
-        wrapperSession: NodeIQQNTWrapperSession
+        wrapperSession: NodeIQQNTWrapperSession,
    ) {
        this.listenerMapping = listenerMapping;
        this.WrapperSession = wrapperSession;
@@ -37,7 +37,7 @@ export class LegacyNTEventWrapper {
            {
                get(target: any, prop: any, receiver: any) {
                    // console.log('get', prop, typeof target[prop]);
-                    if (typeof target[prop] === "undefined") {
+                    if (typeof target[prop] === 'undefined') {
                        // 如果方法不存在，返回一个函数，这个函数调用existentMethod
                        return (...args: any[]) => {
                            current.dispatcherListener.apply(current, [ListenerMainName, prop, ...args]).then();
@@ -46,17 +46,17 @@ export class LegacyNTEventWrapper {
                    // 如果方法存在，正常返回
                    return Reflect.get(target, prop, receiver);
                },
-            }
+            },
        );
    }

    createEventFunction<T extends (...args: any) => any>(eventName: string): T | undefined {
-        const eventNameArr = eventName.split("/");
+        const eventNameArr = eventName.split('/');
        type eventType = {
            [key: string]: () => { [key: string]: (...params: Parameters<T>) => Promise<ReturnType<T>> };
        };
        if (eventNameArr.length > 1) {
-            const serviceName = "get" + eventNameArr[0].replace("NodeIKernel", "");
+            const serviceName = 'get' + eventNameArr[0].replace('NodeIKernel', '');
            const eventName = eventNameArr[1];
            //getNodeIKernelGroupListener,GroupService
            //console.log('2', eventName);
@@ -71,13 +71,13 @@ export class LegacyNTEventWrapper {
        }
    }

-    createListenerFunction<T>(listenerMainName: string, uniqueCode: string = ""): T {
+    createListenerFunction<T>(listenerMainName: string, uniqueCode: string = ''): T {
        const ListenerType = this.listenerMapping![listenerMainName];
        let Listener = this.listenerManager.get(listenerMainName + uniqueCode);
        if (!Listener && ListenerType) {
            Listener = new ListenerType(this.createProxyDispatch(listenerMainName));
            const ServiceSubName = listenerMainName.match(/^NodeIKernel(.*?)Listener$/)![1];
-            const Service = "NodeIKernel" + ServiceSubName + "Service/addKernel" + ServiceSubName + "Listener";
+            const Service = 'NodeIKernel' + ServiceSubName + 'Service/addKernel' + ServiceSubName + 'Listener';
            const addfunc = this.createEventFunction<(listener: T) => number>(Service);
            addfunc!(Listener as T);
            //console.log(addfunc!(Listener as T));
@@ -104,7 +104,7 @@ export class LegacyNTEventWrapper {
    }

    async callNoListenerEvent<EventType extends (...args: any[]) => Promise<any> | any>(
-        EventName = "",
+        EventName = '',
        timeout: number = 3000,
        ...args: Parameters<EventType>
    ) {
@@ -113,7 +113,7 @@ export class LegacyNTEventWrapper {
            let complete = false;
            setTimeout(() => {
                if (!complete) {
-                    reject(new Error("NTEvent EventName:" + EventName + " timeout"));
+                    reject(new Error('NTEvent EventName:' + EventName + ' timeout'));
                }
            }, timeout);
            const retData = await EventFunc!(...args);
@@ -123,13 +123,13 @@ export class LegacyNTEventWrapper {
    }

    async RegisterListen<ListenerType extends (...args: any[]) => void>(
-        ListenerName = "",
+        ListenerName = '',
        waitTimes = 1,
        timeout = 5000,
-        checker: (...args: Parameters<ListenerType>) => boolean
+        checker: (...args: Parameters<ListenerType>) => boolean,
    ) {
        return new Promise<Parameters<ListenerType>>((resolve, reject) => {
-            const ListenerNameList = ListenerName.split("/");
+            const ListenerNameList = ListenerName.split('/');
            const ListenerMainName = ListenerNameList[0];
            const ListenerSubName = ListenerNameList[1];
            const id = randomUUID();
@@ -137,7 +137,7 @@ export class LegacyNTEventWrapper {
            let retData: Parameters<ListenerType> | undefined = undefined;
            const databack = () => {
                if (complete == 0) {
-                    reject(new Error(" ListenerName:" + ListenerName + " timeout"));
+                    reject(new Error(' ListenerName:' + ListenerName + ' timeout'));
                } else {
                    resolve(retData!);
                }
@@ -166,12 +166,13 @@ export class LegacyNTEventWrapper {
            this.createListenerFunction(ListenerMainName);
        });
    }
+
    async CallNormalEvent<
        EventType extends (...args: any[]) => Promise<any>,
        ListenerType extends (...args: any[]) => void
    >(
-        EventName = "",
-        ListenerName = "",
+        EventName = '',
+        ListenerName = '',
        waitTimes = 1,
        timeout: number = 3000,
        checker: (...args: Parameters<ListenerType>) => boolean,
@@ -187,21 +188,21 @@ export class LegacyNTEventWrapper {
                    if (complete == 0) {
                        reject(
                            new Error(
-                                "Timeout: NTEvent EventName:" +
-                                    EventName +
-                                    " ListenerName:" +
-                                    ListenerName +
-                                    " EventRet:\n" +
-                                    JSON.stringify(retEvent, null, 4) +
-                                    "\n"
-                            )
+                                'Timeout: NTEvent EventName:' +
+                                EventName +
+                                ' ListenerName:' +
+                                ListenerName +
+                                ' EventRet:\n' +
+                                JSON.stringify(retEvent, null, 4) +
+                                '\n',
+                            ),
                        );
                    } else {
                        resolve([retEvent as Awaited<ReturnType<EventType>>, ...retData!]);
                    }
                };

-                const ListenerNameList = ListenerName.split("/");
+                const ListenerNameList = ListenerName.split('/');
                const ListenerMainName = ListenerNameList[0];
                const ListenerSubName = ListenerNameList[1];

@@ -231,7 +232,7 @@ export class LegacyNTEventWrapper {
                this.createListenerFunction(ListenerMainName);
                const EventFunc = this.createEventFunction<EventType>(EventName);
                retEvent = await EventFunc!(...(args as any[]));
-            }
+            },
        );
    }
 }
--- a/src/common/framework/event.ts
+++ b/src/common/framework/event.ts
@@ -1,5 +1,5 @@
-import type { NodeIQQNTWrapperSession, WrapperNodeApi } from "@/core/wrapper/wrapper";
-import EventEmitter from "node:events";
+import type { NodeIQQNTWrapperSession, WrapperNodeApi } from '@/core/wrapper/wrapper';
+import EventEmitter from 'node:events';

 export type ListenerClassBase = Record<string, string>;

@@ -12,9 +12,11 @@ export class NTEventChannel extends EventEmitter {
    private wrapperApi: WrapperNodeApi;
    private wrapperSession: NodeIQQNTWrapperSession;
    private listenerRefStorage = new Map<string, ListenerIBase>();
+
    constructor(WrapperApi: WrapperNodeApi, WrapperSession: NodeIQQNTWrapperSession) {
        super();
-        this.on('error', () => { });
+        this.on('error', () => {
+        });
        this.wrapperApi = WrapperApi;
        this.wrapperSession = WrapperSession;
    }
@@ -31,7 +33,7 @@ export class NTEventChannel extends EventEmitter {
                return (...args: any[]) => {
                    current.dispatcherListener.apply(current, [ListenerMainName + '/' + prop, ...args]);
                };
-            }
+            },
        });
    }

@@ -109,7 +111,7 @@ export class NTEventChannel extends EventEmitter {
            //console.log('2', eventName);
            const services = (this.wrapperSession as unknown as eventType)[serviceName]();
            const event = services[eventName]
-            //重新绑定this
+                //重新绑定this
                .bind(services);
            if (event) {
                return event as T;
@@ -134,4 +136,5 @@ export class NTEventChannel extends EventEmitter {
        });
    }
 }
-//NTEvent2.0
+
+//NTEvent2.0
--- a/src/common/framework/napcat.ts
+++ b/src/common/framework/napcat.ts
@@ -1,6 +1,8 @@
-import path, { dirname } from "path";
-import { fileURLToPath } from "url";
-export const napcat_version = "2.0.0";
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+export const napcat_version = '2.0.0';
+
 export class NapCatPathWrapper {
    binaryPath: string;
    logsPath: string;
@@ -8,7 +10,7 @@ export class NapCatPathWrapper {

    constructor(mainPath: string = dirname(fileURLToPath(import.meta.url))) {
        this.binaryPath = mainPath;
-        this.logsPath = path.join(this.binaryPath, "logs");
-        this.configPath = path.join(this.binaryPath, "config");
+        this.logsPath = path.join(this.binaryPath, 'logs');
+        this.configPath = path.join(this.binaryPath, 'config');
    }
 }
--- a/src/common/utils/ConfigBase.ts
+++ b/src/common/utils/ConfigBase.ts
@@ -1,86 +1,91 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import type { NapCatCore } from '@/core';
+
 export class ConfigBase<T> {
-  public name: string = 'default_config';
-  private pathName: string | null = null; // 本次读取的文件路径
-  coreContext: NapCatCore;
-  configPath: string;
-  config: { [key: string]: any } = {};
-  constructor(coreContext: NapCatCore, configPath: string) {
-    this.coreContext = coreContext;
-    this.configPath = configPath;
-    this.read();
-  }
+    public name: string = 'default_config';
+    private pathName: string | null = null; // 本次读取的文件路径
+    coreContext: NapCatCore;
+    configPath: string;
+    config: { [key: string]: any } = {};

-  protected getKeys(): string[] | null {
-    // 决定 key 在json配置文件中的顺序
-    return null;
-  }
-
-  getConfigDir() {
-    const configDir = path.resolve(this.configPath, 'config');
-    fs.mkdirSync(configDir, { recursive: true });
-    return configDir;
-  }
-  getConfigPath(pathName: string | null): string {
-    const suffix = pathName ? `_${pathName}` : '';
-    const filename = `${this.name}${suffix}.json`;
-    return path.join(this.getConfigDir(), filename);
-  }
-  read() {
-    // 尝试加载当前账号配置
-    if (this.read_from_file(this.coreContext.selfInfo.uin, false)) return this;
-    // 尝试加载默认配置
-    return this.read_from_file('', true);
-  }
-  getConfig(): T {
-    return this.config as T;
-  }
-  read_from_file(pathName: string, createIfNotExist: boolean) {
-    const logger = this.coreContext.context.logger;
-    const configPath = this.getConfigPath(pathName);
-    if (!fs.existsSync(configPath)) {
-      if (!createIfNotExist) return null;
-      this.pathName = pathName; // 记录有效的设置文件
-      try {
-        fs.writeFileSync(configPath, JSON.stringify(this.config, this.getKeys(), 2));
-        logger.log(`配置文件${configPath}已创建\n如果修改此文件后需要重启 NapCat 生效`);
-      }
-      catch (e: any) {
-        logger.logError(`创建配置文件 ${configPath} 时发生错误:`, e.message);
-      }
-      return this.config;
+    constructor(coreContext: NapCatCore, configPath: string) {
+        this.coreContext = coreContext;
+        this.configPath = configPath;
+        this.read();
    }

-    try {
-      this.config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-      logger.logDebug(`配置文件${configPath}已加载`, this.config);
-      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-      this.save(); // 保存一次，让新版本的字段写入
-      return this.config;
-    } catch (e: any) {
-      if (e instanceof SyntaxError) {
-        logger.logError(`配置文件 ${configPath} 格式错误，请检查配置文件:`, e.message);
-      } else {
-        logger.logError(`读取配置文件 ${configPath} 时发生错误:`, e.message);
-      }
-      return {};
+    protected getKeys(): string[] | null {
+        // 决定 key 在json配置文件中的顺序
+        return null;
    }
-  }

-  save(configData: T = this.config as T, overwrite: boolean = false) {
-    const logger = this.coreContext.context.logger;
-    const selfInfo = this.coreContext.selfInfo;
-    if (overwrite) {
-      // 用户要求强制写入，则变更当前文件为目标文件
-      this.pathName = `${selfInfo.uin}`;
+    getConfigDir() {
+        const configDir = path.resolve(this.configPath, 'config');
+        fs.mkdirSync(configDir, { recursive: true });
+        return configDir;
    }
-    const configPath = this.getConfigPath(this.pathName);
-    try {
-      fs.writeFileSync(configPath, JSON.stringify(configData, this.getKeys(), 2));
-    } catch (e: any) {
-      logger.logError(`保存配置文件 ${configPath} 时发生错误:`, e.message);
+
+    getConfigPath(pathName: string | null): string {
+        const suffix = pathName ? `_${pathName}` : '';
+        const filename = `${this.name}${suffix}.json`;
+        return path.join(this.getConfigDir(), filename);
+    }
+
+    read() {
+        // 尝试加载当前账号配置
+        if (this.read_from_file(this.coreContext.selfInfo.uin, false)) return this;
+        // 尝试加载默认配置
+        return this.read_from_file('', true);
+    }
+
+    getConfig(): T {
+        return this.config as T;
+    }
+
+    read_from_file(pathName: string, createIfNotExist: boolean) {
+        const logger = this.coreContext.context.logger;
+        const configPath = this.getConfigPath(pathName);
+        if (!fs.existsSync(configPath)) {
+            if (!createIfNotExist) return null;
+            this.pathName = pathName; // 记录有效的设置文件
+            try {
+                fs.writeFileSync(configPath, JSON.stringify(this.config, this.getKeys(), 2));
+                logger.log(`配置文件${configPath}已创建\n如果修改此文件后需要重启 NapCat 生效`);
+            } catch (e: any) {
+                logger.logError(`创建配置文件 ${configPath} 时发生错误:`, e.message);
+            }
+            return this.config;
+        }
+
+        try {
+            this.config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+            logger.logDebug(`配置文件${configPath}已加载`, this.config);
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            this.save(); // 保存一次，让新版本的字段写入
+            return this.config;
+        } catch (e: any) {
+            if (e instanceof SyntaxError) {
+                logger.logError(`配置文件 ${configPath} 格式错误，请检查配置文件:`, e.message);
+            } else {
+                logger.logError(`读取配置文件 ${configPath} 时发生错误:`, e.message);
+            }
+            return {};
+        }
+    }
+
+    save(configData: T = this.config as T, overwrite: boolean = false) {
+        const logger = this.coreContext.context.logger;
+        const selfInfo = this.coreContext.selfInfo;
+        if (overwrite) {
+            // 用户要求强制写入，则变更当前文件为目标文件
+            this.pathName = `${selfInfo.uin}`;
+        }
+        const configPath = this.getConfigPath(this.pathName);
+        try {
+            fs.writeFileSync(configPath, JSON.stringify(configData, this.getKeys(), 2));
+        } catch (e: any) {
+            logger.logError(`保存配置文件 ${configPath} 时发生错误:`, e.message);
+        }
    }
-  }
 }
--- a/src/common/utils/MessageUnique.ts
+++ b/src/common/utils/MessageUnique.ts
@@ -1,5 +1,6 @@
 import { Peer } from '@/core';
 import crypto from 'crypto';
+
 export class LimitedHashTable<K, V> {
    private keyToValue: Map<K, V> = new Map();
    private valueToKey: Map<V, K> = new Map();
@@ -8,15 +9,16 @@ export class LimitedHashTable<K, V> {
    constructor(maxSize: number) {
        this.maxSize = maxSize;
    }
+
    resize(count: number) {
        this.maxSize = count;
    }

    set(key: K, value: V): void {
-    // const isExist = this.keyToValue.get(key);
-    // if (isExist && isExist === value) {
-    //   return;
-    // }
+        // const isExist = this.keyToValue.get(key);
+        // if (isExist && isExist === value) {
+        //   return;
+        // }
        this.keyToValue.set(key, value);
        this.valueToKey.set(value, key);
        while (this.keyToValue.size !== this.valueToKey.size) {
@@ -63,6 +65,7 @@ export class LimitedHashTable<K, V> {
    getKeyList(): K[] {
        return Array.from(this.keyToValue.keys());
    }
+
    //获取最近刚写入的几个值
    getHeads(size: number): { key: K; value: V }[] | undefined {
        const keyList = this.getKeyList();
@@ -82,10 +85,12 @@ export class LimitedHashTable<K, V> {
 class MessageUniqueWrapper {
    private msgDataMap: LimitedHashTable<string, number>;
    private msgIdMap: LimitedHashTable<string, number>;
+
    constructor(maxMap: number = 1000) {
        this.msgIdMap = new LimitedHashTable<string, number>(maxMap);
        this.msgDataMap = new LimitedHashTable<string, number>(maxMap);
    }
+
    getRecentMsgIds(Peer: Peer, size: number): string[] {
        const heads = this.msgIdMap.getHeads(size);
        if (!heads) {
@@ -95,6 +100,7 @@ class MessageUniqueWrapper {
        const ret = data.filter((t) => t?.Peer.chatType === Peer.chatType && t?.Peer.peerUid === Peer.peerUid);
        return ret.map((t) => t?.MsgId).filter((t) => t !== undefined);
    }
+
    createMsg(peer: Peer, msgId: string): number | undefined {
        const key = `${msgId}|${peer.chatType}|${peer.peerUid}`;
        const hash = crypto.createHash('md5').update(key).digest();
@@ -128,11 +134,13 @@ class MessageUniqueWrapper {
    getShortIdByMsgId(msgId: string): number | undefined {
        return this.msgIdMap.getValue(msgId);
    }
+
    getPeerByMsgId(msgId: string) {
        const shortId = this.msgIdMap.getValue(msgId);
        if (!shortId) return undefined;
        return this.getMsgIdAndPeerByShortId(shortId);
    }
+
    resize(maxSize: number): void {
        this.msgIdMap.resize(maxSize);
        this.msgDataMap.resize(maxSize);
--- a/src/common/utils/QQBasicInfo.ts
+++ b/src/common/utils/QQBasicInfo.ts
@@ -1,9 +1,9 @@
-import path from "node:path";
-import fs from "node:fs";
-import { systemPlatform } from "@/common/utils/system";
-import { getDefaultQQVersionConfigInfo, getQQVersionConfigPath } from "./helper";
-import AppidTable from "@/core/external/appid.json";
-import { LogWrapper } from "./log";
+import path from 'node:path';
+import fs from 'node:fs';
+import { systemPlatform } from '@/common/utils/system';
+import { getDefaultQQVersionConfigInfo, getQQVersionConfigPath } from './helper';
+import AppidTable from '@/core/external/appid.json';
+import { LogWrapper } from './log';

 export class QQBasicInfoWrapper {
    QQMainPath: string | undefined;
@@ -20,7 +20,7 @@ export class QQBasicInfoWrapper {
        //基础目录获取
        this.context = context;
        this.QQMainPath = process.execPath;
-        this.QQPackageInfoPath = path.join(path.dirname(this.QQMainPath), "resources", "app", "package.json");
+        this.QQPackageInfoPath = path.join(path.dirname(this.QQMainPath), 'resources', 'app', 'package.json');
        this.QQVersionConfigPath = getQQVersionConfigPath(this.QQMainPath);

        //基础信息获取 无快更则启用默认模板填充
@@ -40,27 +40,29 @@ export class QQBasicInfoWrapper {
    }

    getFullQQVesion() {
-        const version =  this.isQuickUpdate ? this.QQVersionConfig?.curVersion : this.QQPackageInfo?.version;
-        if(!version) throw new Error("QQ版本获取失败");
+        const version = this.isQuickUpdate ? this.QQVersionConfig?.curVersion : this.QQPackageInfo?.version;
+        if (!version) throw new Error('QQ版本获取失败');
        return version;
    }

    requireMinNTQQBuild(buildStr: string) {
-        const currentBuild = parseInt(this.getQQBuildStr() || "0");
-        if (currentBuild == 0) throw new Error("QQBuildStr获取失败");
+        const currentBuild = parseInt(this.getQQBuildStr() || '0');
+        if (currentBuild == 0) throw new Error('QQBuildStr获取失败');
        return currentBuild >= parseInt(buildStr);
    }
+
    //此方法不要直接使用
    getQUAInternal() {
-        return systemPlatform === "linux"
+        return systemPlatform === 'linux'
            ? `V1_LNX_NQ_${this.getFullQQVesion()}_${this.getQQBuildStr()}_GW_B`
            : `V1_WIN_NQ_${this.getFullQQVesion()}_${this.getQQBuildStr()}_GW_B`;
    }
+
    getAppidV2(): { appid: string; qua: string } {
        const appidTbale = AppidTable as unknown as QQAppidTableType;
        try {
            const fullVersion = this.getFullQQVesion();
-            if (!fullVersion) throw new Error("QQ版本获取失败");
+            if (!fullVersion) throw new Error('QQ版本获取失败');
            const data = appidTbale[fullVersion];
            if (data) {
                return data;
@@ -70,9 +72,10 @@ export class QQBasicInfoWrapper {
        }
        // 以下是兜底措施
        this.context.logger.log(
-            `[QQ版本兼容性检测] ${this.getFullQQVesion()} 版本兼容性不佳，可能会导致一些功能无法正常使用`
+            `[QQ版本兼容性检测] ${this.getFullQQVesion()} 版本兼容性不佳，可能会导致一些功能无法正常使用`,
        );
-        return { appid: systemPlatform === "linux" ? "537237950" : "537237765", qua: this.getQUAInternal() };
+        return { appid: systemPlatform === 'linux' ? '537237950' : '537237765', qua: this.getQUAInternal() };
    }
 }
+
 export let QQBasicInfo: QQBasicInfoWrapper | undefined;
--- a/src/common/utils/audio.ts
+++ b/src/common/utils/audio.ts
@@ -1,88 +1,90 @@
 import fs from 'fs';
-import { encode, getDuration, getWavFileInfo, isWav, isSilk } from 'silk-wasm';
+import { encode, getDuration, getWavFileInfo, isSilk, isWav } from 'silk-wasm';
 import fsPromise from 'fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'crypto';
 import { spawn } from 'node:child_process';
 import { LogWrapper } from './log';
-export async function encodeSilk(filePath: string, TEMP_DIR: string, logger: LogWrapper) {
-  async function guessDuration(pttPath: string) {
-    const pttFileInfo = await fsPromise.stat(pttPath);
-    let duration = pttFileInfo.size / 1024 / 3;  // 3kb/s
-    duration = Math.floor(duration);
-    duration = Math.max(1, duration);
-    logger.log('通过文件大小估算语音的时长:', duration);
-    return duration;
-  }
-  try {
-    const file = await fsPromise.readFile(filePath);
-    const pttPath = path.join(TEMP_DIR, randomUUID());
-    if (!isSilk(file)) {
-      logger.log(`语音文件${filePath}需要转换成silk`);
-      const _isWav = isWav(file);
-      const pcmPath = pttPath + '.pcm';
-      let sampleRate = 0;
-      const convert = () => {
-        return new Promise<Buffer>((resolve, reject) => {
-          // todo: 通过配置文件获取ffmpeg路径
-          const ffmpegPath = process.env.FFMPEG_PATH || 'ffmpeg';
-          const cp = spawn(ffmpegPath, ['-y', '-i', filePath, '-ar', '24000', '-ac', '1', '-f', 's16le', pcmPath]);
-          cp.on('error', err => {
-            logger.log('FFmpeg处理转换出错: ', err.message);
-            return reject(err);
-          });
-          cp.on('exit', (code, signal) => {
-            const EXIT_CODES = [0, 255];
-            if (code == null || EXIT_CODES.includes(code)) {
-              sampleRate = 24000;
-              const data = fs.readFileSync(pcmPath);
-              fs.unlink(pcmPath, (err) => {
-              });
-              return resolve(data);
-            }
-            logger.log(`FFmpeg exit: code=${code ?? 'unknown'} sig=${signal ?? 'unknown'}`);
-            reject(Error('FFmpeg处理转换失败'));
-          });
-        });
-      };
-      let input: Buffer;
-      if (!_isWav) {
-        input = await convert();
-      } else {
-        input = file;
-        const allowSampleRate = [8000, 12000, 16000, 24000, 32000, 44100, 48000];
-        const { fmt } = getWavFileInfo(input);
-        // log(`wav文件信息`, fmt)
-        if (!allowSampleRate.includes(fmt.sampleRate)) {
-          input = await convert();
-        }
-      }
-      const silk = await encode(input, sampleRate);
-      fs.writeFileSync(pttPath, silk.data);
-      logger.log(`语音文件${filePath}转换成功!`, pttPath, '时长:', silk.duration);
-      return {
-        converted: true,
-        path: pttPath,
-        duration: silk.duration / 1000
-      };
-    } else {
-      const silk = file;
-      let duration = 0;
-      try {
-        duration = getDuration(silk) / 1000;
-      } catch (e: any) {
-        logger.log('获取语音文件时长失败, 使用文件大小推测时长', filePath, e.stack);
-        duration = await guessDuration(filePath);
-      }

-      return {
-        converted: false,
-        path: filePath,
-        duration,
-      };
+export async function encodeSilk(filePath: string, TEMP_DIR: string, logger: LogWrapper) {
+    async function guessDuration(pttPath: string) {
+        const pttFileInfo = await fsPromise.stat(pttPath);
+        let duration = pttFileInfo.size / 1024 / 3;  // 3kb/s
+        duration = Math.floor(duration);
+        duration = Math.max(1, duration);
+        logger.log('通过文件大小估算语音的时长:', duration);
+        return duration;
+    }
+
+    try {
+        const file = await fsPromise.readFile(filePath);
+        const pttPath = path.join(TEMP_DIR, randomUUID());
+        if (!isSilk(file)) {
+            logger.log(`语音文件${filePath}需要转换成silk`);
+            const _isWav = isWav(file);
+            const pcmPath = pttPath + '.pcm';
+            let sampleRate = 0;
+            const convert = () => {
+                return new Promise<Buffer>((resolve, reject) => {
+                    // todo: 通过配置文件获取ffmpeg路径
+                    const ffmpegPath = process.env.FFMPEG_PATH || 'ffmpeg';
+                    const cp = spawn(ffmpegPath, ['-y', '-i', filePath, '-ar', '24000', '-ac', '1', '-f', 's16le', pcmPath]);
+                    cp.on('error', err => {
+                        logger.log('FFmpeg处理转换出错: ', err.message);
+                        return reject(err);
+                    });
+                    cp.on('exit', (code, signal) => {
+                        const EXIT_CODES = [0, 255];
+                        if (code == null || EXIT_CODES.includes(code)) {
+                            sampleRate = 24000;
+                            const data = fs.readFileSync(pcmPath);
+                            fs.unlink(pcmPath, (err) => {
+                            });
+                            return resolve(data);
+                        }
+                        logger.log(`FFmpeg exit: code=${code ?? 'unknown'} sig=${signal ?? 'unknown'}`);
+                        reject(Error('FFmpeg处理转换失败'));
+                    });
+                });
+            };
+            let input: Buffer;
+            if (!_isWav) {
+                input = await convert();
+            } else {
+                input = file;
+                const allowSampleRate = [8000, 12000, 16000, 24000, 32000, 44100, 48000];
+                const { fmt } = getWavFileInfo(input);
+                // log(`wav文件信息`, fmt)
+                if (!allowSampleRate.includes(fmt.sampleRate)) {
+                    input = await convert();
+                }
+            }
+            const silk = await encode(input, sampleRate);
+            fs.writeFileSync(pttPath, silk.data);
+            logger.log(`语音文件${filePath}转换成功!`, pttPath, '时长:', silk.duration);
+            return {
+                converted: true,
+                path: pttPath,
+                duration: silk.duration / 1000,
+            };
+        } else {
+            const silk = file;
+            let duration = 0;
+            try {
+                duration = getDuration(silk) / 1000;
+            } catch (e: any) {
+                logger.log('获取语音文件时长失败, 使用文件大小推测时长', filePath, e.stack);
+                duration = await guessDuration(filePath);
+            }
+
+            return {
+                converted: false,
+                path: filePath,
+                duration,
+            };
+        }
+    } catch (error: any) {
+        logger.logError('convert silk failed', error.stack);
+        return {};
    }
-  } catch (error: any) {
-    logger.logError('convert silk failed', error.stack);
-    return {};
-  }
 }
--- a/src/common/utils/file.ts
+++ b/src/common/utils/file.ts
@@ -1,299 +1,301 @@
 import fs from 'fs';
 import fsPromise, { stat } from 'fs/promises';
-import crypto from 'crypto';
+import crypto, { randomUUID } from 'crypto';
 import util from 'util';
 import path from 'node:path';
 import * as fileType from 'file-type';
-import { randomUUID } from 'crypto';
 import { LogWrapper } from './log';

 export function isGIF(path: string) {
-  const buffer = Buffer.alloc(4);
-  const fd = fs.openSync(path, 'r');
-  fs.readSync(fd, buffer, 0, 4, 0);
-  fs.closeSync(fd);
-  return buffer.toString() === 'GIF8';
+    const buffer = Buffer.alloc(4);
+    const fd = fs.openSync(path, 'r');
+    fs.readSync(fd, buffer, 0, 4, 0);
+    fs.closeSync(fd);
+    return buffer.toString() === 'GIF8';
 }

 // 定义一个异步函数来检查文件是否存在
 export function checkFileReceived(path: string, timeout: number = 3000): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now();
+    return new Promise((resolve, reject) => {
+        const startTime = Date.now();

-    function check() {
-      if (fs.existsSync(path)) {
-        resolve();
-      } else if (Date.now() - startTime > timeout) {
-        reject(new Error(`文件不存在: ${path}`));
-      } else {
-        setTimeout(check, 100);
-      }
-    }
+        function check() {
+            if (fs.existsSync(path)) {
+                resolve();
+            } else if (Date.now() - startTime > timeout) {
+                reject(new Error(`文件不存在: ${path}`));
+            } else {
+                setTimeout(check, 100);
+            }
+        }

-    check();
-  });
+        check();
+    });
 }
+
 // 定义一个异步函数来检查文件是否存在
 export async function checkFileReceived2(path: string, timeout: number = 3000): Promise<void> {
-  // 使用 Promise.race 来同时进行文件状态检查和超时计时
-  // Promise.race 会返回第一个解决（resolve）或拒绝（reject）的 Promise
-  await Promise.race([
-    checkFile(path),
-    timeoutPromise(timeout, `文件不存在: ${path}`),
-  ]);
+    // 使用 Promise.race 来同时进行文件状态检查和超时计时
+    // Promise.race 会返回第一个解决（resolve）或拒绝（reject）的 Promise
+    await Promise.race([
+        checkFile(path),
+        timeoutPromise(timeout, `文件不存在: ${path}`),
+    ]);
 }

 // 转换超时时间至 Promise
 function timeoutPromise(timeout: number, errorMsg: string): Promise<void> {
-  return new Promise((_, reject) => {
-    setTimeout(() => {
-      reject(new Error(errorMsg));
-    }, timeout);
-  });
+    return new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(errorMsg));
+        }, timeout);
+    });
 }

 // 异步检查文件是否存在
 async function checkFile(path: string): Promise<void> {
-  try {
-    await stat(path);
-  } catch (error: any) {
-    if (error.code === 'ENOENT') {
-      // 如果文件不存在，则抛出一个错误
-      throw new Error(`文件不存在: ${path}`);
-    } else {
-      // 对于 stat 调用的其他错误，重新抛出
-      throw error;
-    }
-  }
-  // 如果文件存在，则无需做任何事情，Promise 解决（resolve）自身
-}
-export async function file2base64(path: string) {
-  const readFile = util.promisify(fs.readFile);
-  const result = {
-    err: '',
-    data: ''
-  };
-  try {
-    // 读取文件内容
-    // if (!fs.existsSync(path)){
-    //     path = path.replace("\\Ori\\", "\\Thumb\\");
-    // }
    try {
-      await checkFileReceived(path, 5000);
-    } catch (e: any) {
-      result.err = e.toString();
-      return result;
+        await stat(path);
+    } catch (error: any) {
+        if (error.code === 'ENOENT') {
+            // 如果文件不存在，则抛出一个错误
+            throw new Error(`文件不存在: ${path}`);
+        } else {
+            // 对于 stat 调用的其他错误，重新抛出
+            throw error;
+        }
    }
-    const data = await readFile(path);
-    // 转换为Base64编码
-    result.data = data.toString('base64');
-  } catch (err: any) {
-    result.err = err.toString();
-  }
-  return result;
+    // 如果文件存在，则无需做任何事情，Promise 解决（resolve）自身
+}
+
+export async function file2base64(path: string) {
+    const readFile = util.promisify(fs.readFile);
+    const result = {
+        err: '',
+        data: '',
+    };
+    try {
+        // 读取文件内容
+        // if (!fs.existsSync(path)){
+        //     path = path.replace("\\Ori\\", "\\Thumb\\");
+        // }
+        try {
+            await checkFileReceived(path, 5000);
+        } catch (e: any) {
+            result.err = e.toString();
+            return result;
+        }
+        const data = await readFile(path);
+        // 转换为Base64编码
+        result.data = data.toString('base64');
+    } catch (err: any) {
+        result.err = err.toString();
+    }
+    return result;
 }


 export function calculateFileMD5(filePath: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    // 创建一个流式读取器
-    const stream = fs.createReadStream(filePath);
-    const hash = crypto.createHash('md5');
+    return new Promise((resolve, reject) => {
+        // 创建一个流式读取器
+        const stream = fs.createReadStream(filePath);
+        const hash = crypto.createHash('md5');

-    stream.on('data', (data: Buffer) => {
-      // 当读取到数据时，更新哈希对象的状态
-      hash.update(data);
-    });
+        stream.on('data', (data: Buffer) => {
+            // 当读取到数据时，更新哈希对象的状态
+            hash.update(data);
+        });

-    stream.on('end', () => {
-      // 文件读取完成，计算哈希
-      const md5 = hash.digest('hex');
-      resolve(md5);
-    });
+        stream.on('end', () => {
+            // 文件读取完成，计算哈希
+            const md5 = hash.digest('hex');
+            resolve(md5);
+        });

-    stream.on('error', (err: Error) => {
-      // 处理可能的读取错误
-      reject(err);
+        stream.on('error', (err: Error) => {
+            // 处理可能的读取错误
+            reject(err);
+        });
    });
-  });
 }

 export interface HttpDownloadOptions {
-  url: string;
-  headers?: Record<string, string> | string;
+    url: string;
+    headers?: Record<string, string> | string;
 }

 export async function httpDownload(options: string | HttpDownloadOptions): Promise<Buffer> {
-  const chunks: Buffer[] = [];
-  let url: string;
-  let headers: Record<string, string> = {
-    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36'
-  };
-  if (typeof options === 'string') {
-    url = options;
-    const host = new URL(url).hostname;
-    headers['Host'] = host;
-  } else {
-    url = options.url;
-    if (options.headers) {
-      if (typeof options.headers === 'string') {
-        headers = JSON.parse(options.headers);
-      } else {
-        headers = options.headers;
-      }
+    const chunks: Buffer[] = [];
+    let url: string;
+    let headers: Record<string, string> = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/94.0.4606.71 Safari/537.36',
+    };
+    if (typeof options === 'string') {
+        url = options;
+        const host = new URL(url).hostname;
+        headers['Host'] = host;
+    } else {
+        url = options.url;
+        if (options.headers) {
+            if (typeof options.headers === 'string') {
+                headers = JSON.parse(options.headers);
+            } else {
+                headers = options.headers;
+            }
+        }
    }
-  }
-  const fetchRes = await fetch(url, { headers }).catch((err) => {
-    if (err.cause) {
-      throw err.cause;
-    }
-    throw err;
-  });
-  if (!fetchRes.ok) throw new Error(`下载文件失败: ${fetchRes.statusText}`);
+    const fetchRes = await fetch(url, { headers }).catch((err) => {
+        if (err.cause) {
+            throw err.cause;
+        }
+        throw err;
+    });
+    if (!fetchRes.ok) throw new Error(`下载文件失败: ${fetchRes.statusText}`);

-  const blob = await fetchRes.blob();
-  const buffer = await blob.arrayBuffer();
-  return Buffer.from(buffer);
+    const blob = await fetchRes.blob();
+    const buffer = await blob.arrayBuffer();
+    return Buffer.from(buffer);
 }

 type Uri2LocalRes = {
-  success: boolean,
-  errMsg: string,
-  fileName: string,
-  ext: string,
-  path: string,
-  isLocal: boolean
+    success: boolean,
+    errMsg: string,
+    fileName: string,
+    ext: string,
+    path: string,
+    isLocal: boolean
 }

 export async function uri2local(TempDir: string, UriOrPath: string, fileName: string | null = null): Promise<Uri2LocalRes> {
-  const res = {
-    success: false,
-    errMsg: '',
-    fileName: '',
-    ext: '',
-    path: '',
-    isLocal: false
-  };
-  if (!fileName) fileName = randomUUID();
-  let filePath = path.join(TempDir, fileName);//临时目录
-  let url = null;
-  //区分path和uri
-  try {
-    if (fs.existsSync(UriOrPath)) url = new URL('file://' + UriOrPath);
-  } catch (error: any) { }
-  try {
-    url = new URL(UriOrPath);
-  } catch (error: any) { }
-
-  //验证url
-  if (!url) {
-    res.errMsg = `UriOrPath ${UriOrPath} 解析失败,可能${UriOrPath}不存在`;
-    return res;
-  }
-
-  if (url.protocol == 'base64:') {
-    // base64转成文件
-    const base64Data = UriOrPath.split('base64://')[1];
+    const res = {
+        success: false,
+        errMsg: '',
+        fileName: '',
+        ext: '',
+        path: '',
+        isLocal: false,
+    };
+    if (!fileName) fileName = randomUUID();
+    let filePath = path.join(TempDir, fileName);//临时目录
+    let url = null;
+    //区分path和uri
    try {
-      const buffer = Buffer.from(base64Data, 'base64');
-      fs.writeFileSync(filePath, buffer);
-    } catch (e: any) {
-      res.errMsg = 'base64文件下载失败,' + e.toString();
-      return res;
-    }
-  } else if (url.protocol == 'http:' || url.protocol == 'https:') {
-    // 下载文件
-    let buffer: Buffer | null = null;
-    try {
-      buffer = await httpDownload(UriOrPath);
-    } catch (e: any) {
-      res.errMsg = `${url}下载失败,` + e.toString();
-      return res;
+        if (fs.existsSync(UriOrPath)) url = new URL('file://' + UriOrPath);
+    } catch (error: any) {
    }
    try {
-      const pathInfo = path.parse(decodeURIComponent(url.pathname));
-      if (pathInfo.name) {
-        fileName = pathInfo.name;
-        if (pathInfo.ext) {
-          fileName += pathInfo.ext;
-          // res.ext = pathInfo.ext
+        url = new URL(UriOrPath);
+    } catch (error: any) {
+    }
+
+    //验证url
+    if (!url) {
+        res.errMsg = `UriOrPath ${UriOrPath} 解析失败,可能${UriOrPath}不存在`;
+        return res;
+    }
+
+    if (url.protocol == 'base64:') {
+        // base64转成文件
+        const base64Data = UriOrPath.split('base64://')[1];
+        try {
+            const buffer = Buffer.from(base64Data, 'base64');
+            fs.writeFileSync(filePath, buffer);
+        } catch (e: any) {
+            res.errMsg = 'base64文件下载失败,' + e.toString();
+            return res;
        }
-      }
-      fileName = fileName.replace(/[/\\:*?"<>|]/g, '_');
-      res.fileName = fileName;
-      filePath = path.join(TempDir, randomUUID() + fileName);
-      fs.writeFileSync(filePath, buffer);
-    } catch (e: any) {
-      res.errMsg = `${url}下载失败,` + e.toString();
-      return res;
+    } else if (url.protocol == 'http:' || url.protocol == 'https:') {
+        // 下载文件
+        let buffer: Buffer | null = null;
+        try {
+            buffer = await httpDownload(UriOrPath);
+        } catch (e: any) {
+            res.errMsg = `${url}下载失败,` + e.toString();
+            return res;
+        }
+        try {
+            const pathInfo = path.parse(decodeURIComponent(url.pathname));
+            if (pathInfo.name) {
+                fileName = pathInfo.name;
+                if (pathInfo.ext) {
+                    fileName += pathInfo.ext;
+                    // res.ext = pathInfo.ext
+                }
+            }
+            fileName = fileName.replace(/[/\\:*?"<>|]/g, '_');
+            res.fileName = fileName;
+            filePath = path.join(TempDir, randomUUID() + fileName);
+            fs.writeFileSync(filePath, buffer);
+        } catch (e: any) {
+            res.errMsg = `${url}下载失败,` + e.toString();
+            return res;
+        }
+    } else {
+        let pathname: string;
+        if (url.protocol === 'file:') {
+            // await fs.copyFile(url.pathname, filePath);
+            pathname = decodeURIComponent(url.pathname);
+            if (process.platform === 'win32') {
+                filePath = pathname.slice(1);
+            } else {
+                filePath = pathname;
+            }
+        } else {
+            // 26702执行forword file文件操作 不应该在这里乱来
+            // const cache = await dbUtil.getFileCacheByName(uri);
+            // if (cache) {
+            //   filePath = cache.path;
+            // } else {
+            //   filePath = uri;
+            // }
+        }
+        res.isLocal = true;
    }
-  } else {
-    let pathname: string;
-    if (url.protocol === 'file:') {
-      // await fs.copyFile(url.pathname, filePath);
-      pathname = decodeURIComponent(url.pathname);
-      if (process.platform === 'win32') {
-        filePath = pathname.slice(1);
-      } else {
-        filePath = pathname;
-      }
+    // else{
+    //     res.errMsg = `不支持的file协议,` + url.protocol
+    //     return res
+    // }
+    // if (isGIF(filePath) && !res.isLocal) {
+    //     await fs.rename(filePath, filePath + ".gif");
+    //     filePath += ".gif";
+    // }
+    if (!res.isLocal && !res.ext) {
+        try {
+            const ext: string | undefined = (await fileType.fileTypeFromFile(filePath))?.ext;
+            if (ext) {
+                fs.renameSync(filePath, filePath + `.${ext}`);
+                filePath += `.${ext}`;
+                res.fileName += `.${ext}`;
+                res.ext = ext;
+            }
+        } catch (e) {
+            // log("获取文件类型失败", filePath,e.stack)
+        }
    }
-    else {
-      // 26702执行forword file文件操作 不应该在这里乱来
-      // const cache = await dbUtil.getFileCacheByName(uri);
-      // if (cache) {
-      //   filePath = cache.path;
-      // } else {
-      //   filePath = uri;
-      // }
-    }
-    res.isLocal = true;
-  }
-  // else{
-  //     res.errMsg = `不支持的file协议,` + url.protocol
-  //     return res
-  // }
-  // if (isGIF(filePath) && !res.isLocal) {
-  //     await fs.rename(filePath, filePath + ".gif");
-  //     filePath += ".gif";
-  // }
-  if (!res.isLocal && !res.ext) {
-    try {
-      const ext: string | undefined = (await fileType.fileTypeFromFile(filePath))?.ext;
-      if (ext) {
-        fs.renameSync(filePath, filePath + `.${ext}`);
-        filePath += `.${ext}`;
-        res.fileName += `.${ext}`;
-        res.ext = ext;
-      }
-    } catch (e) {
-      // log("获取文件类型失败", filePath,e.stack)
-    }
-  }
-  res.success = true;
-  res.path = filePath;
-  return res;
+    res.success = true;
+    res.path = filePath;
+    return res;
 }

 export async function copyFolder(sourcePath: string, destPath: string, logger: LogWrapper) {
-  try {
-    const entries = await fsPromise.readdir(sourcePath, { withFileTypes: true });
-    await fsPromise.mkdir(destPath, { recursive: true });
-    for (const entry of entries) {
-      const srcPath = path.join(sourcePath, entry.name);
-      const dstPath = path.join(destPath, entry.name);
-      if (entry.isDirectory()) {
-        await copyFolder(srcPath, dstPath, logger);
-      } else {
-        try {
-          await fsPromise.copyFile(srcPath, dstPath);
-        } catch (error) {
-          logger.logError(`无法复制文件 '${srcPath}' 到 '${dstPath}': ${error}`);
-          // 这里可以决定是否要继续复制其他文件
+    try {
+        const entries = await fsPromise.readdir(sourcePath, { withFileTypes: true });
+        await fsPromise.mkdir(destPath, { recursive: true });
+        for (const entry of entries) {
+            const srcPath = path.join(sourcePath, entry.name);
+            const dstPath = path.join(destPath, entry.name);
+            if (entry.isDirectory()) {
+                await copyFolder(srcPath, dstPath, logger);
+            } else {
+                try {
+                    await fsPromise.copyFile(srcPath, dstPath);
+                } catch (error) {
+                    logger.logError(`无法复制文件 '${srcPath}' 到 '${dstPath}': ${error}`);
+                    // 这里可以决定是否要继续复制其他文件
+                }
+            }
        }
-      }
+    } catch (error) {
+        logger.logError('复制文件夹时出错:', error);
    }
-  } catch (error) {
-    logger.logError('复制文件夹时出错:', error);
-  }
 }
--- a/src/common/utils/helper.ts
+++ b/src/common/utils/helper.ts
@@ -1,9 +1,9 @@
-import crypto from "node:crypto";
-import path from "node:path";
-import fs from "fs";
-import * as fsPromise from "node:fs/promises";
-import os from "node:os";
-import { QQLevel } from "@/core";
+import crypto from 'node:crypto';
+import path from 'node:path';
+import fs from 'fs';
+import * as fsPromise from 'node:fs/promises';
+import os from 'node:os';
+import { QQLevel } from '@/core';

 //下面这个类是用于将uid+msgid合并的类

@@ -11,19 +11,20 @@ export class UUIDConverter {
    static encode(highStr: string, lowStr: string): string {
        const high = BigInt(highStr);
        const low = BigInt(lowStr);
-        const highHex = high.toString(16).padStart(16, "0");
-        const lowHex = low.toString(16).padStart(16, "0");
+        const highHex = high.toString(16).padStart(16, '0');
+        const lowHex = low.toString(16).padStart(16, '0');
        const combinedHex = highHex + lowHex;
        const uuid = `${combinedHex.substring(0, 8)}-${combinedHex.substring(8, 12)}-${combinedHex.substring(
            12,
-            16
+            16,
        )}-${combinedHex.substring(16, 20)}-${combinedHex.substring(20)}`;
        return uuid;
    }
+
    static decode(uuid: string): { high: string; low: string } {
-        const hex = uuid.replace(/-/g, "");
-        const high = BigInt("0x" + hex.substring(0, 16));
-        const low = BigInt("0x" + hex.substring(16));
+        const hex = uuid.replace(/-/g, '');
+        const high = BigInt('0x' + hex.substring(0, 16));
+        const low = BigInt('0x' + hex.substring(16));
        return { high: high.toString(), low: low.toString() };
    }
 }
@@ -34,27 +35,28 @@ export function sleep(ms: number): Promise<void> {

 export function PromiseTimer<T>(promise: Promise<T>, ms: number): Promise<T> {
    const timeoutPromise = new Promise<T>((_, reject) =>
-        setTimeout(() => reject(new Error("PromiseTimer: Operation timed out")), ms)
+        setTimeout(() => reject(new Error('PromiseTimer: Operation timed out')), ms),
    );
    return Promise.race([promise, timeoutPromise]);
 }
+
 export async function runAllWithTimeout<T>(tasks: Promise<T>[], timeout: number): Promise<T[]> {
    const wrappedTasks = tasks.map((task) =>
        PromiseTimer(task, timeout).then(
-            (result) => ({ status: "fulfilled", value: result }),
-            (error) => ({ status: "rejected", reason: error })
-        )
+            (result) => ({ status: 'fulfilled', value: result }),
+            (error) => ({ status: 'rejected', reason: error }),
+        ),
    );
    const results = await Promise.all(wrappedTasks);
    return results
-        .filter((result) => result.status === "fulfilled")
-        .map((result) => (result as { status: "fulfilled"; value: T }).value);
+        .filter((result) => result.status === 'fulfilled')
+        .map((result) => (result as { status: 'fulfilled'; value: T }).value);
 }

 export function getMd5(s: string) {
-    const h = crypto.createHash("md5");
+    const h = crypto.createHash('md5');
    h.update(s);
-    return h.digest("hex");
+    return h.digest('hex');
 }

 export function isNull(value: any) {
@@ -64,15 +66,16 @@ export function isNull(value: any) {
 export function isNumeric(str: string) {
    return /^\d+$/.test(str);
 }
+
 export function truncateString(obj: any, maxLength = 500) {
-    if (obj !== null && typeof obj === "object") {
+    if (obj !== null && typeof obj === 'object') {
        Object.keys(obj).forEach((key) => {
-            if (typeof obj[key] === "string") {
+            if (typeof obj[key] === 'string') {
                // 如果是字符串且超过指定长度，则截断
                if (obj[key].length > maxLength) {
-                    obj[key] = obj[key].substring(0, maxLength) + "...";
+                    obj[key] = obj[key].substring(0, maxLength) + '...';
                }
-            } else if (typeof obj[key] === "object") {
+            } else if (typeof obj[key] === 'object') {
                // 如果是对象或数组，则递归调用
                truncateString(obj[key], maxLength);
            }
@@ -80,10 +83,11 @@ export function truncateString(obj: any, maxLength = 500) {
    }
    return obj;
 }
+
 export function isEqual(obj1: any, obj2: any) {
    if (obj1 === obj2) return true;
    if (obj1 == null || obj2 == null) return false;
-    if (typeof obj1 !== "object" || typeof obj2 !== "object") return obj1 === obj2;
+    if (typeof obj1 !== 'object' || typeof obj2 !== 'object') return obj1 === obj2;

    const keys1 = Object.keys(obj1);
    const keys2 = Object.keys(obj2);
@@ -95,35 +99,36 @@ export function isEqual(obj1: any, obj2: any) {
    }
    return true;
 }
+
 export function getDefaultQQVersionConfigInfo(): QQVersionConfigType {
-    if (os.platform() === "linux") {
+    if (os.platform() === 'linux') {
        return {
-            baseVersion: "3.2.12-26702",
-            curVersion: "3.2.12-26702",
-            prevVersion: "",
+            baseVersion: '3.2.12-26702',
+            curVersion: '3.2.12-26702',
+            prevVersion: '',
            onErrorVersions: [],
-            buildId: "26702",
+            buildId: '26702',
        };
    }
    return {
-        baseVersion: "9.9.15-26702",
-        curVersion: "9.9.15-26702",
-        prevVersion: "",
+        baseVersion: '9.9.15-26702',
+        curVersion: '9.9.15-26702',
+        prevVersion: '',
        onErrorVersions: [],
-        buildId: "26702",
+        buildId: '26702',
    };
 }

-export function getQQVersionConfigPath(exePath: string = ""): string | undefined {
+export function getQQVersionConfigPath(exePath: string = ''): string | undefined {
    let configVersionInfoPath;
-    if (os.platform() !== "linux") {
-        configVersionInfoPath = path.join(path.dirname(exePath), "resources", "app", "versions", "config.json");
+    if (os.platform() !== 'linux') {
+        configVersionInfoPath = path.join(path.dirname(exePath), 'resources', 'app', 'versions', 'config.json');
    } else {
        const userPath = os.homedir();
-        const appDataPath = path.resolve(userPath, "./.config/QQ");
-        configVersionInfoPath = path.resolve(appDataPath, "./versions/config.json");
+        const appDataPath = path.resolve(userPath, './.config/QQ');
+        configVersionInfoPath = path.resolve(appDataPath, './versions/config.json');
    }
-    if (typeof configVersionInfoPath !== "string") {
+    if (typeof configVersionInfoPath !== 'string') {
        return undefined;
    }
    if (!fs.existsSync(configVersionInfoPath)) {
@@ -153,7 +158,8 @@ export async function deleteOldFiles(directoryPath: string, daysThreshold: numbe
        //console.error('Error deleting files:', error);
    }
 }
+
 export function calcQQLevel(level: QQLevel) {
-  const { crownNum, sunNum, moonNum, starNum } = level;
-  return crownNum * 64 + sunNum * 16 + moonNum * 4 + starNum;
+    const { crownNum, sunNum, moonNum, starNum } = level;
+    return crownNum * 64 + sunNum * 16 + moonNum * 4 + starNum;
 }
--- a/src/common/utils/log.ts
+++ b/src/common/utils/log.ts
@@ -2,13 +2,15 @@ import log4js, { Configuration } from 'log4js';
 import { truncateString } from '@/common/utils/helper';
 import path from 'node:path';
 import chalk from 'chalk';
+
 export enum LogLevel {
-  DEBUG = 'debug',
-  INFO = 'info',
-  WARN = 'warn',
-  ERROR = 'error',
-  FATAL = 'fatal',
+    DEBUG = 'debug',
+    INFO = 'info',
+    WARN = 'warn',
+    ERROR = 'error',
+    FATAL = 'fatal',
 }
+
 function getFormattedTimestamp() {
    const now = new Date();
    const year = now.getFullYear();
@@ -20,6 +22,7 @@ function getFormattedTimestamp() {
    const milliseconds = now.getMilliseconds().toString().padStart(3, '0');
    return `${year}-${month}-${day}_${hours}-${minutes}-${seconds}.${milliseconds}`;
 }
+
 export class LogWrapper {
    fileLogEnabled = true;
    consoleLogEnabled = true;
@@ -29,8 +32,9 @@ export class LogWrapper {
    loggerDefault: log4js.Logger;
    // eslint-disable-next-line no-control-regex
    colorEscape = /\x1B[@-_][0-?]*[ -/]*[@-~]/g;
+
    constructor(logDir: string) {
-    // logDir = path.join(path.resolve(__dirname), 'logs');
+        // logDir = path.join(path.resolve(__dirname), 'logs');
        const filename = `${getFormattedTimestamp()}.log`;
        const logPath = path.join(logDir, filename);
        this.logConfig = {
@@ -41,22 +45,22 @@ export class LogWrapper {
                    maxLogSize: 10485760, // 日志文件的最大大小（单位：字节），这里设置为10MB
                    layout: {
                        type: 'pattern',
-                        pattern: '%d{yyyy-MM-dd hh:mm:ss} [%p] %X{userInfo} | %m'
-                    }
+                        pattern: '%d{yyyy-MM-dd hh:mm:ss} [%p] %X{userInfo} | %m',
+                    },
                },
                ConsoleAppender: { // 输出到控制台的appender
                    type: 'console',
                    layout: {
                        type: 'pattern',
-                        pattern: `%d{yyyy-MM-dd hh:mm:ss} [%[%p%]] ${chalk.magenta('%X{userInfo}')} | %m`
-                    }
-                }
+                        pattern: `%d{yyyy-MM-dd hh:mm:ss} [%[%p%]] ${chalk.magenta('%X{userInfo}')} | %m`,
+                    },
+                },
            },
            categories: {
                default: { appenders: ['FileAppender', 'ConsoleAppender'], level: 'debug' }, // 默认情况下同时输出到文件和控制台
                file: { appenders: ['FileAppender'], level: 'debug' },
-                console: { appenders: ['ConsoleAppender'], level: 'debug' }
-            }
+                console: { appenders: ['ConsoleAppender'], level: 'debug' },
+            },
        };
        log4js.configure(this.logConfig);
        this.loggerConsole = log4js.getLogger('console');
@@ -64,6 +68,7 @@ export class LogWrapper {
        this.loggerDefault = log4js.getLogger('default');
        this.setLogSelfInfo({ nick: '', uin: '', uid: '' });
    }
+
    setLogLevel(fileLogLevel: LogLevel, consoleLogLevel: LogLevel) {
        this.logConfig.categories.file.level = fileLogLevel;
        this.logConfig.categories.console.level = consoleLogLevel;
@@ -81,6 +86,7 @@ export class LogWrapper {
    enableFileLog(enable: boolean) {
        this.fileLogEnabled = enable;
    }
+
    enableConsoleLog(enable: boolean) {
        this.consoleLogEnabled = enable;
    }
@@ -102,7 +108,6 @@ export class LogWrapper {
    }


-
    _log(level: LogLevel, ...args: any[]) {
        if (this.consoleLogEnabled) {
            this.loggerConsole[level](this.formatMsg(args));
@@ -113,7 +118,7 @@ export class LogWrapper {
    }

    log(...args: any[]) {
-    // info 等级
+        // info 等级
        this._log(LogLevel.INFO, ...args);
    }

--- a/src/common/utils/proxy-handler.ts
+++ b/src/common/utils/proxy-handler.ts
@@ -1,4 +1,4 @@
-import { LogWrapper } from "./log";
+import { LogWrapper } from './log';

 export function proxyHandlerOf(logger: LogWrapper) {
    return {
@@ -12,10 +12,10 @@ export function proxyHandlerOf(logger: LogWrapper) {
            }
            // 如果方法存在，正常返回
            return Reflect.get(target, prop, receiver);
-        }
+        },
    };
 }

 export function proxiedListenerOf<T extends object>(listener: T, logger: LogWrapper) {
    return new Proxy<T>(listener, proxyHandlerOf(logger));
-}
+}
--- a/src/common/utils/request.ts
+++ b/src/common/utils/request.ts
@@ -1,6 +1,7 @@
 import https from 'node:https';
 import http from 'node:http';
 import { readFileSync } from 'node:fs';
+
 export class RequestUtil {
    // 适用于获取服务器下发cookies时获取，仅GET
    static async HttpsGetCookies(url: string): Promise<{ [key: string]: string }> {
@@ -27,7 +28,8 @@ export class RequestUtil {
                        resolve(cookies);
                    }
                };
-                res.on('data', () => { }); // Necessary to consume the stream
+                res.on('data', () => {
+                }); // Necessary to consume the stream
                res.on('end', () => {
                    handleRedirect(res);
                });
@@ -45,14 +47,15 @@ export class RequestUtil {
            });
            req.on('error', (error: any) => {
                reject(error);
-            }); 
+            });
        });
    }


-
    // 请求和回复都是JSON data传原始内容 自动编码json
-    static async HttpGetJson<T>(url: string, method: string = 'GET', data?: any, headers: { [key: string]: string } = {}, isJsonRet: boolean = true, isArgJson: boolean = true): Promise<T> {
+    static async HttpGetJson<T>(url: string, method: string = 'GET', data?: any, headers: {
+        [key: string]: string
+    } = {}, isJsonRet: boolean = true, isArgJson: boolean = true): Promise<T> {
        const option = new URL(url);
        const protocol = url.startsWith('https://') ? https : http;
        const options = {
@@ -60,7 +63,7 @@ export class RequestUtil {
            port: option.port,
            path: option.href,
            method: method,
-            headers: headers
+            headers: headers,
        };
        // headers: {
        //       'Content-Type': 'application/json',
@@ -119,7 +122,7 @@ export class RequestUtil {
        const formDataParts = [
            `------${boundary}\r\n`,
            `Content-Disposition: form-data; name="share_image"; filename="${filePath}"\r\n`,
-            'Content-Type: ' + type + '\r\n\r\n'
+            'Content-Type: ' + type + '\r\n\r\n',
        ];

        const fileContent = readFileSync(filePath);
@@ -127,65 +130,65 @@ export class RequestUtil {
        return Buffer.concat([
            Buffer.from(formDataParts.join(''), 'utf8'),
            fileContent,
-            Buffer.from(footer, 'utf8')
+            Buffer.from(footer, 'utf8'),
        ]);
    }

-    static async uploadImageForOpenPlatform(filePath: string,cookies:string): Promise<string> {
+    static async uploadImageForOpenPlatform(filePath: string, cookies: string): Promise<string> {
        return new Promise(async (resolve, reject) => {
-      type retType = { retcode: number, result?: { url: string } };
-      try {
-          const options = {
-              hostname: 'cgi.connect.qq.com',
-              port: 443,
-              path: '/qqconnectopen/upload_share_image',
-              method: 'POST',
-              headers: {
-                  'Referer': 'https://cgi.connect.qq.com',
-                  'Cookie': cookies,
-                  'Accept': '*/*',
-                  'Connection': 'keep-alive',
-                  'Content-Type': 'multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW'
-              }
-          };
-          const req = https.request(options, async (res) => {
-              let responseBody = '';
+            type retType = { retcode: number, result?: { url: string } };
+            try {
+                const options = {
+                    hostname: 'cgi.connect.qq.com',
+                    port: 443,
+                    path: '/qqconnectopen/upload_share_image',
+                    method: 'POST',
+                    headers: {
+                        'Referer': 'https://cgi.connect.qq.com',
+                        'Cookie': cookies,
+                        'Accept': '*/*',
+                        'Connection': 'keep-alive',
+                        'Content-Type': 'multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW',
+                    },
+                };
+                const req = https.request(options, async (res) => {
+                    let responseBody = '';

-              res.on('data', (chunk: string | Buffer) => {
-                  responseBody += chunk.toString();
-              });
+                    res.on('data', (chunk: string | Buffer) => {
+                        responseBody += chunk.toString();
+                    });

-              res.on('end', () => {
-                  try {
-                      if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                          const responseJson = JSON.parse(responseBody) as retType;
-                          resolve(responseJson.result!.url!);
-                      } else {
-                          reject(new Error(`Unexpected status code: ${res.statusCode}`));
-                      }
-                  } catch (parseError) {
-                      reject(parseError);
-                  }
+                    res.on('end', () => {
+                        try {
+                            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                                const responseJson = JSON.parse(responseBody) as retType;
+                                resolve(responseJson.result!.url!);
+                            } else {
+                                reject(new Error(`Unexpected status code: ${res.statusCode}`));
+                            }
+                        } catch (parseError) {
+                            reject(parseError);
+                        }

-              });
+                    });

-          });
+                });

-          req.on('error', (error) => {
-              reject(error);
-              console.error('Error during upload:', error);
-          });
+                req.on('error', (error) => {
+                    reject(error);
+                    console.error('Error during upload:', error);
+                });

-          const body = await RequestUtil.createFormData('WebKitFormBoundary7MA4YWxkTrZu0gW', filePath);
-          // req.setHeader('Content-Length', Buffer.byteLength(body));
-          // console.log(`Prepared data size: ${Buffer.byteLength(body)} bytes`);
-          req.write(body);
-          req.end();
-          return;
-      } catch (error) {
-          reject(error);
-      }
-      return undefined;
+                const body = await RequestUtil.createFormData('WebKitFormBoundary7MA4YWxkTrZu0gW', filePath);
+                // req.setHeader('Content-Length', Buffer.byteLength(body));
+                // console.log(`Prepared data size: ${Buffer.byteLength(body)} bytes`);
+                req.write(body);
+                req.end();
+                return;
+            } catch (error) {
+                reject(error);
+            }
+            return undefined;
        });
    }
 }
--- a/src/common/utils/system.ts
+++ b/src/common/utils/system.ts
@@ -17,7 +17,7 @@ try {
 const invalidMacAddresses = new Set([
    '00:00:00:00:00:00',
    'ff:ff:ff:ff:ff:ff',
-    'ac:de:48:00:11:22'
+    'ac:de:48:00:11:22',
 ]);

 function validateMacAddress(candidate: string): boolean {
@@ -70,4 +70,4 @@ export const cpuArch = os.arch();
 export const systemVersion = os.release();
 export const hostname = osName;
 export const downloadsPath = path.join(homeDir, 'Downloads');
-export const systemName = os.type();
+export const systemName = os.type();
--- a/src/common/utils/types.ts
+++ b/src/common/utils/types.ts
@@ -1,17 +1,17 @@
 //QQVersionType
 type QQPackageInfoType = {
-  version: string;
-  buildVersion: string;
-  platform: string;
-  eleArch: string;
+    version: string;
+    buildVersion: string;
+    platform: string;
+    eleArch: string;
 }
 type QQVersionConfigType = {
-  baseVersion: string;
-  curVersion: string;
-  prevVersion: string;
-  onErrorVersions: Array<any>;
-  buildId: string;
+    baseVersion: string;
+    curVersion: string;
+    prevVersion: string;
+    onErrorVersions: Array<any>;
+    buildId: string;
 }
 type QQAppidTableType = {
-  [key: string]: { appid: string, qua: string };
-}
+    [key: string]: { appid: string, qua: string };
+}
--- a/src/common/utils/video.ts
+++ b/src/common/utils/video.ts
@@ -2,57 +2,58 @@ import ffmpeg, { FfprobeStream } from 'fluent-ffmpeg';
 import fs from 'fs';
 import type { LogWrapper } from './log';

-export async function getVideoInfo(filePath: string,logger:LogWrapper) {
-  const size = fs.statSync(filePath).size;
-  return new Promise<{
-    width: number,
-    height: number,
-    time: number,
-    format: string,
-    size: number,
-    filePath: string
-  }>((resolve, reject) => {
-    const ffmpegPath = process.env.FFMPEG_PATH;
-    ffmpegPath && ffmpeg.setFfmpegPath(ffmpegPath);
-    ffmpeg(filePath).ffprobe((err: any, metadata: ffmpeg.FfprobeData) => {
-      if (err) {
-        reject(err);
-      } else {
-        const videoStream = metadata.streams.find((s: FfprobeStream) => s.codec_type === 'video');
-        if (videoStream) {
-          logger.log(`视频尺寸: ${videoStream.width}x${videoStream.height}`);
-        } else {
-          return reject('未找到视频流信息。');
-        }
-        resolve({
-          width: videoStream.width!, height: videoStream.height!,
-          time: parseInt(videoStream.duration!),
-          format: metadata.format.format_name!,
-          size,
-          filePath
+export async function getVideoInfo(filePath: string, logger: LogWrapper) {
+    const size = fs.statSync(filePath).size;
+    return new Promise<{
+        width: number,
+        height: number,
+        time: number,
+        format: string,
+        size: number,
+        filePath: string
+    }>((resolve, reject) => {
+        const ffmpegPath = process.env.FFMPEG_PATH;
+        ffmpegPath && ffmpeg.setFfmpegPath(ffmpegPath);
+        ffmpeg(filePath).ffprobe((err: any, metadata: ffmpeg.FfprobeData) => {
+            if (err) {
+                reject(err);
+            } else {
+                const videoStream = metadata.streams.find((s: FfprobeStream) => s.codec_type === 'video');
+                if (videoStream) {
+                    logger.log(`视频尺寸: ${videoStream.width}x${videoStream.height}`);
+                } else {
+                    return reject('未找到视频流信息。');
+                }
+                resolve({
+                    width: videoStream.width!, height: videoStream.height!,
+                    time: parseInt(videoStream.duration!),
+                    format: metadata.format.format_name!,
+                    size,
+                    filePath,
+                });
+            }
        });
-      }
    });
-  });
 }
-export function checkFfmpeg(newPath: string | null = null,logger:LogWrapper): Promise<boolean> {
-  return new Promise((resolve, reject) => {
-    logger.log('开始检查ffmpeg', newPath);
-    if (newPath) {
-      ffmpeg.setFfmpegPath(newPath);
-    }
-    try {
-      ffmpeg.getAvailableFormats((err: any, formats: any) => {
-        if (err) {
-          logger.log('ffmpeg is not installed or not found in PATH:', err);
-          resolve(false);
-        } else {
-          logger.log('ffmpeg is installed.');
-          resolve(true);
+
+export function checkFfmpeg(newPath: string | null = null, logger: LogWrapper): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+        logger.log('开始检查ffmpeg', newPath);
+        if (newPath) {
+            ffmpeg.setFfmpegPath(newPath);
        }
-      });
-    } catch (e) {
-      resolve(false);
-    }
-  });
+        try {
+            ffmpeg.getAvailableFormats((err: any, formats: any) => {
+                if (err) {
+                    logger.log('ffmpeg is not installed or not found in PATH:', err);
+                    resolve(false);
+                } else {
+                    logger.log('ffmpeg is installed.');
+                    resolve(true);
+                }
+            });
+        } catch (e) {
+            resolve(false);
+        }
+    });
 }