refactor: 整体重构 (#1381)

* feat: pnpm new * Refactor build and release workflows, update dependencies Switch build scripts and workflows from npm to pnpm, update build and artifact paths, and simplify release workflow by removing version detection and changelog steps. Add new dependencies (silk-wasm, express, ws, node-pty-prebuilt-multiarch), update exports in package.json files, and add vite config for napcat-framework. Also, rename manifest.json for framework package and fix static asset copying in shell build config.
2026-02-06 13:05:09 +00:00 · 2025-11-13 15:39:42 +08:00
parent c3d1892545
commit ed19c52f25
778 changed files with 2356 additions and 26391 deletions
--- a/packages/napcat-shell/base.ts
+++ b/packages/napcat-shell/base.ts
@@ -0,0 +1,458 @@
+import type { SelfInfo } from 'napcat-core/types';
+
+import { LogWrapper } from 'napcat-common/src/log';
+import { NodeIKernelLoginListener, NodeIKernelSessionListener } from 'napcat-core/listeners';
+import { NodeIDependsAdapter, NodeIDispatcherAdapter, NodeIGlobalAdapter } from 'napcat-core/adapters';
+import { NapCatPathWrapper } from 'napcat-common/src/path';
+import {
+  genSessionConfig,
+  InstanceContext,
+  loadQQWrapper,
+  NapCatCore,
+  NapCatCoreWorkingEnv,
+  NodeIQQNTStartupSessionWrapper,
+  NodeIQQNTWrapperEngine,
+  NodeIQQNTWrapperSession,
+  PlatformType,
+  WrapperNodeApi,
+  WrapperSessionInitConfig,
+} from 'napcat-core';
+import { QQBasicInfoWrapper } from 'napcat-common/src/qq-basic-info';
+import { hostname, systemVersion } from 'napcat-common/src/system';
+import { proxiedListenerOf } from 'napcat-common/src/proxy-handler';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { LoginListItem, NodeIKernelLoginService } from 'napcat-core/services';
+import qrcode from 'napcat-qrcode/lib/main';
+import { NapCatOneBot11Adapter } from 'napcat-onebot/index';
+import { InitWebUi } from 'napcat-webui-backend/src/index';
+import { WebUiDataRuntime } from 'napcat-webui-backend/src/helper/Data';
+import { napCatVersion } from 'napcat-common/src/version';
+import { NodeIO3MiscListener } from 'napcat-core/listeners/NodeIO3MiscListener';
+import { sleep } from 'napcat-common/src/helper';
+import { FFmpegService } from 'napcat-common/src/ffmpeg';
+import { connectToNamedPipe } from './pipe';
+import { NativePacketHandler } from 'napcat-core/packet/handler/client';
+// NapCat Shell App ES 入口文件
+async function handleUncaughtExceptions (logger: LogWrapper) {
+  process.on('uncaughtException', (err) => {
+    logger.logError('[NapCat] [Error] Unhandled Exception:', err.message);
+  });
+  process.on('unhandledRejection', (reason) => {
+    logger.logError('[NapCat] [Error] unhandledRejection:', reason);
+  });
+}
+
+function getDataPaths (wrapper: WrapperNodeApi): [string, string] {
+  if (os.platform() === 'darwin') {
+    const userPath = os.homedir();
+    const appDataPath = path.resolve(userPath, './Library/Application Support/QQ');
+    return [appDataPath, path.join(appDataPath, 'global')];
+  }
+  let dataPath = wrapper.NodeQQNTWrapperUtil.getNTUserDataInfoConfig();
+  if (!dataPath) {
+    dataPath = path.resolve(os.homedir(), './.config/QQ');
+    fs.mkdirSync(dataPath, { recursive: true });
+  }
+  const dataPathGlobal = path.resolve(dataPath, './nt_qq/global');
+  return [dataPath, dataPathGlobal];
+}
+
+function getPlatformType (): PlatformType {
+  const platformMapping: Partial<Record<NodeJS.Platform, PlatformType>> = {
+    win32: PlatformType.KWINDOWS,
+    darwin: PlatformType.KMAC,
+    linux: PlatformType.KLINUX,
+  };
+  return platformMapping[os.platform()] ?? PlatformType.KWINDOWS;
+}
+
+async function initializeEngine (
+  engine: NodeIQQNTWrapperEngine,
+  basicInfoWrapper: QQBasicInfoWrapper,
+  dataPathGlobal: string,
+  systemPlatform: PlatformType,
+  systemVersion: string
+) {
+  engine.initWithDeskTopConfig(
+    {
+      base_path_prefix: '',
+      platform_type: systemPlatform,
+      app_type: 4,
+      app_version: basicInfoWrapper.getFullQQVersion(),
+      os_version: systemVersion,
+      use_xlog: false,
+      qua: basicInfoWrapper.QQVersionQua ?? '',
+      global_path_config: {
+        desktopGlobalPath: dataPathGlobal,
+      },
+      thumb_config: { maxSide: 324, minSide: 48, longLimit: 6, density: 2 },
+    },
+    new NodeIGlobalAdapter()
+  );
+}
+
+async function initializeLoginService (
+  loginService: NodeIKernelLoginService,
+  basicInfoWrapper: QQBasicInfoWrapper,
+  dataPathGlobal: string,
+  systemVersion: string,
+  hostname: string
+) {
+  loginService.initConfig({
+    machineId: '',
+    appid: basicInfoWrapper.QQVersionAppid ?? '',
+    platVer: systemVersion,
+    commonPath: dataPathGlobal,
+    clientVer: basicInfoWrapper.getFullQQVersion(),
+    hostName: hostname,
+  });
+}
+
+async function handleLogin (
+  loginService: NodeIKernelLoginService,
+  logger: LogWrapper,
+  pathWrapper: NapCatPathWrapper,
+  quickLoginUin: string | undefined,
+  historyLoginList: LoginListItem[]
+): Promise<SelfInfo> {
+  const context = { isLogined: false };
+  let inner_resolve: (value: SelfInfo) => void;
+  const selfInfo: Promise<SelfInfo> = new Promise((resolve) => {
+    inner_resolve = resolve;
+  });
+  // 连接服务
+
+  const loginListener = new NodeIKernelLoginListener();
+  loginListener.onUserLoggedIn = (userid: string) => {
+    logger.logError(`当前账号(${userid})已登录,无法重复登录`);
+  };
+  loginListener.onQRCodeLoginSucceed = async (loginResult) => {
+    context.isLogined = true;
+    inner_resolve({
+      uid: loginResult.uid,
+      uin: loginResult.uin,
+      nick: '',
+      online: true,
+    });
+  };
+  loginListener.onLoginConnected = () => {
+    waitForNetworkConnection(loginService, logger).then(() => {
+      handleLoginInner(context, logger, loginService, quickLoginUin, historyLoginList).then().catch(e => logger.logError(e));
+      loginListener.onLoginConnected = () => { };
+    });
+  };
+  loginListener.onQRCodeGetPicture = ({ pngBase64QrcodeData, qrcodeUrl }) => {
+    WebUiDataRuntime.setQQLoginQrcodeURL(qrcodeUrl);
+
+    const realBase64 = pngBase64QrcodeData.replace(/^data:image\/\w+;base64,/, '');
+    const buffer = Buffer.from(realBase64, 'base64');
+    logger.logWarn('请扫描下面的二维码，然后在手Q上授权登录：');
+    const qrcodePath = path.join(pathWrapper.cachePath, 'qrcode.png');
+    qrcode.generate(qrcodeUrl, { small: true }, (res) => {
+      logger.logWarn([
+        '\n',
+        res,
+        '二维码解码URL: ' + qrcodeUrl,
+        '如果控制台二维码无法扫码，可以复制解码url到二维码生成网站生成二维码再扫码，也可以打开下方的二维码路径图片进行扫码。',
+      ].join('\n'));
+      fs.writeFile(qrcodePath, buffer, {}, () => {
+        logger.logWarn('二维码已保存到', qrcodePath);
+      });
+    });
+  };
+
+  loginListener.onQRCodeSessionFailed = (errType: number, errCode: number) => {
+    if (!context.isLogined) {
+      logger.logError('[Core] [Login] Login Error,ErrType: ', errType, ' ErrCode:', errCode);
+      if (errType === 1 && errCode === 3) {
+        // 二维码过期刷新
+      }
+      loginService.getQRCodePicture();
+    }
+  };
+
+  loginListener.onLoginFailed = (...args) => {
+    logger.logError('[Core] [Login] Login Error , ErrInfo: ', JSON.stringify(args));
+  };
+
+  loginService.addKernelLoginListener(proxiedListenerOf(loginListener, logger));
+  loginService.connect();
+  return await selfInfo;
+}
+async function handleLoginInner (context: { isLogined: boolean; }, logger: LogWrapper, loginService: NodeIKernelLoginService, quickLoginUin: string | undefined, historyLoginList: LoginListItem[]) {
+  WebUiDataRuntime.setQuickLoginCall(async (uin: string) => {
+    return await new Promise((resolve) => {
+      if (uin) {
+        logger.log('正在快速登录 ', uin);
+        loginService.quickLoginWithUin(uin).then(res => {
+          if (res.loginErrorInfo.errMsg) {
+            resolve({ result: false, message: res.loginErrorInfo.errMsg });
+          }
+          resolve({ result: true, message: '' });
+        }).catch((e) => {
+          logger.logError(e);
+          resolve({ result: false, message: '快速登录发生错误' });
+        });
+      } else {
+        resolve({ result: false, message: '快速登录失败' });
+      }
+    });
+  });
+  if (quickLoginUin) {
+    if (historyLoginList.some(u => u.uin === quickLoginUin)) {
+      logger.log('正在快速登录 ', quickLoginUin);
+      loginService.quickLoginWithUin(quickLoginUin)
+        .then(result => {
+          if (result.loginErrorInfo.errMsg) {
+            logger.logError('快速登录错误：', result.loginErrorInfo.errMsg);
+            if (!context.isLogined) loginService.getQRCodePicture();
+          }
+        })
+        .catch();
+    } else {
+      logger.logError('快速登录失败，未找到该 QQ 历史登录记录，将使用二维码登录方式');
+      if (!context.isLogined) loginService.getQRCodePicture();
+    }
+  } else {
+    logger.log('没有 -q 指令指定快速登录，将使用二维码登录方式');
+    if (historyLoginList.length > 0) {
+      logger.log(`可用于快速登录的 QQ：\n${historyLoginList
+        .map((u, index) => `${index + 1}. ${u.uin} ${u.nickName}`)
+        .join('\n')
+        }`);
+    }
+    loginService.getQRCodePicture();
+    try {
+      await WebUiDataRuntime.runWebUiConfigQuickFunction();
+    } catch (error) {
+      logger.logError('WebUi 快速登录失败 执行失败', error);
+    }
+  }
+
+  loginService.getLoginList().then((res) => {
+    // 遍历 res.LocalLoginInfoList[x].isQuickLogin是否可以 res.LocalLoginInfoList[x].uin 转为string 加入string[] 最后遍历完成调用WebUiDataRuntime.setQQQuickLoginList
+    const list = res.LocalLoginInfoList.filter((item) => item.isQuickLogin);
+    WebUiDataRuntime.setQQQuickLoginList(list.map((item) => item.uin.toString()));
+    WebUiDataRuntime.setQQNewLoginList(list);
+  });
+}
+
+async function initializeSession (
+  session: NodeIQQNTWrapperSession,
+  sessionConfig: WrapperSessionInitConfig,
+  startupSession: NodeIQQNTStartupSessionWrapper | null
+) {
+  return new Promise<void>((resolve, reject) => {
+    const sessionListener = new NodeIKernelSessionListener();
+    sessionListener.onOpentelemetryInit = (info) => {
+      if (info.is_init) {
+        resolve();
+      } else {
+        reject(new Error('opentelemetry init failed'));
+      }
+    };
+    session.init(
+      sessionConfig,
+      new NodeIDependsAdapter(),
+      new NodeIDispatcherAdapter(),
+      sessionListener
+    );
+    if (startupSession) {
+      startupSession.start();
+    } else {
+      try {
+        session.startNT(0);
+      } catch {
+        try {
+          session.startNT();
+        } catch (e: unknown) {
+          reject(new Error('init failed ' + (e as Error).message));
+        }
+      }
+    }
+  });
+}
+async function handleProxy (session: NodeIQQNTWrapperSession, logger: LogWrapper) {
+  if (process.env['NAPCAT_PROXY_PORT']) {
+    session.getMSFService().setNetworkProxy({
+      userName: '',
+      userPwd: '',
+      address: process.env['NAPCAT_PROXY_ADDRESS'] || '127.0.0.1',
+      port: +process.env['NAPCAT_PROXY_PORT'],
+      proxyType: 2,
+      domain: '',
+      isSocket: true,
+    });
+    logger.logWarn('已设置代理', process.env['NAPCAT_PROXY_ADDRESS'], process.env['NAPCAT_PROXY_PORT']);
+  } else if (process.env['NAPCAT_PROXY_CLOSE']) {
+    session.getMSFService().setNetworkProxy({
+      userName: '',
+      userPwd: '',
+      address: '',
+      port: 0,
+      proxyType: 0,
+      domain: '',
+      isSocket: false,
+    });
+  }
+}
+
+async function waitForNetworkConnection (loginService: NodeIKernelLoginService, logger: LogWrapper) {
+  let network_ok = false;
+  let _tryCount = 0;
+  while (!network_ok) {
+    network_ok = loginService.getMsfStatus() !== 3;// win 11 0连接 1未连接
+    logger.log('等待网络连接...');
+    await sleep(500);
+    _tryCount++;
+  }
+  logger.log('网络已连接');
+  return network_ok;
+}
+
+export async function NCoreInitShell () {
+  console.log('NapCat Shell App Loading...');
+  const pathWrapper = new NapCatPathWrapper();
+  const logger = new LogWrapper(pathWrapper.logsPath);
+  handleUncaughtExceptions(logger);
+
+  // 初始化 FFmpeg 服务
+  await FFmpegService.init(pathWrapper.binaryPath, logger);
+
+  if (process.env['NAPCAT_DISABLE_PIPE'] !== '1') {
+    await connectToNamedPipe(logger).catch(e => logger.logError('命名管道连接失败', e));
+  }
+  const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
+  const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVersion());
+  const nativePacketHandler = new NativePacketHandler({ logger }); // 初始化 NativePacketHandler 用于后续使用
+
+  // nativePacketHandler.onAll((packet) => {
+  //     console.log('[Packet]', packet.uin, packet.cmd, packet.hex_data);
+  // });
+  await nativePacketHandler.init(basicInfoWrapper.getFullQQVersion());
+
+  const o3Service = wrapper.NodeIO3MiscService.get();
+  o3Service.addO3MiscListener(new NodeIO3MiscListener());
+
+  logger.log('[NapCat] [Core] NapCat.Core Version: ' + napCatVersion);
+  InitWebUi(logger, pathWrapper).then().catch(e => logger.logError(e));
+
+  const engine = wrapper.NodeIQQNTWrapperEngine.get();
+  const loginService = wrapper.NodeIKernelLoginService.get();
+  let session: NodeIQQNTWrapperSession;
+  let startupSession: NodeIQQNTStartupSessionWrapper | null = null;
+  try {
+    startupSession = wrapper.NodeIQQNTStartupSessionWrapper.create();
+    session = wrapper.NodeIQQNTWrapperSession.getNTWrapperSession('nt_1');
+  } catch (e: unknown) {
+    try {
+      session = wrapper.NodeIQQNTWrapperSession.create();
+    } catch (error) {
+      logger.logError('创建 StartupSession 失败', e);
+      logger.logError('创建 Session 失败', error);
+      throw error;
+    }
+  }
+  const [dataPath, dataPathGlobal] = getDataPaths(wrapper);
+  const systemPlatform = getPlatformType();
+
+  if (!basicInfoWrapper.QQVersionAppid || !basicInfoWrapper.QQVersionQua) throw new Error('QQVersionAppid or QQVersionQua  is not defined');
+
+  await initializeEngine(engine, basicInfoWrapper, dataPathGlobal, systemPlatform, systemVersion);
+  await initializeLoginService(loginService, basicInfoWrapper, dataPathGlobal, systemVersion, hostname);
+  handleProxy(session, logger);
+
+  let quickLoginUin: string | undefined = undefined;
+  try {
+    const args = process.argv;
+    const qIndex = args.findIndex(arg => arg === '-q' || arg === '--qq');
+    if (qIndex !== -1 && qIndex + 1 < args.length) {
+      quickLoginUin = args[qIndex + 1];
+    }
+  } catch (error) {
+    logger.logWarn('解析命令行参数失败，无法使用快速登录功能', error);
+  }
+
+  const historyLoginList = (await loginService.getLoginList()).LocalLoginInfoList;
+
+  const dataTimestape = new Date().getTime().toString();
+  o3Service.reportAmgomWeather('login', 'a1', [dataTimestape, '0', '0']);
+
+  const selfInfo = await handleLogin(loginService, logger, pathWrapper, quickLoginUin, historyLoginList);
+  const amgomDataPiece = 'eb1fd6ac257461580dc7438eb099f23aae04ca679f4d88f53072dc56e3bb1129';
+  o3Service.setAmgomDataPiece(basicInfoWrapper.QQVersionAppid, new Uint8Array(Buffer.from(amgomDataPiece, 'hex')));
+
+  let guid = loginService.getMachineGuid();
+  guid = guid.slice(0, 8) + '-' + guid.slice(8, 12) + '-' + guid.slice(12, 16) + '-' + guid.slice(16, 20) + '-' + guid.slice(20);
+  o3Service.reportAmgomWeather('login', 'a6', [dataTimestape, '184', '329']);
+
+  const sessionConfig = await genSessionConfig(
+    guid,
+    basicInfoWrapper.QQVersionAppid,
+    basicInfoWrapper.getFullQQVersion(),
+    selfInfo.uin,
+    selfInfo.uid,
+    dataPath
+  );
+
+  await initializeSession(session, sessionConfig, startupSession);
+
+  const accountDataPath = path.resolve(dataPath, './NapCat/data');
+  // 判断dataPath是否为根目录 或者 D:/ 之类的盘目录
+  if (dataPath !== '/' && /^[a-zA-Z]:\\$/.test(dataPath) === false) {
+    try {
+      fs.mkdirSync(accountDataPath, { recursive: true });
+    } catch (error) {
+      logger.logError('创建accountDataPath失败', error);
+    }
+  }
+
+  logger.logDebug('本账号数据/缓存目录：', accountDataPath);
+
+  await new NapCatShell(
+    wrapper,
+    session,
+    logger,
+    loginService,
+    selfInfo,
+    basicInfoWrapper,
+    pathWrapper,
+    nativePacketHandler
+  ).InitNapCat();
+}
+
+export class NapCatShell {
+  readonly core: NapCatCore;
+  readonly context: InstanceContext;
+
+  constructor (
+    wrapper: WrapperNodeApi,
+    session: NodeIQQNTWrapperSession,
+    logger: LogWrapper,
+    loginService: NodeIKernelLoginService,
+    selfInfo: SelfInfo,
+    basicInfoWrapper: QQBasicInfoWrapper,
+    pathWrapper: NapCatPathWrapper,
+    packetHandler: NativePacketHandler
+  ) {
+    this.context = {
+      packetHandler,
+      workingEnv: NapCatCoreWorkingEnv.Shell,
+      wrapper,
+      session,
+      logger,
+      loginService,
+      basicInfoWrapper,
+      pathWrapper,
+    };
+    this.core = new NapCatCore(this.context, selfInfo);
+  }
+
+  async InitNapCat () {
+    await this.core.initCore();
+    new NapCatOneBot11Adapter(this.core, this.context, this.context.pathWrapper).InitOneBot()
+      .catch(e => this.context.logger.logError('初始化OneBot失败', e));
+  }
+}
--- a/packages/napcat-shell/napcat.ts
+++ b/packages/napcat-shell/napcat.ts
@@ -0,0 +1,2 @@
+import { NCoreInitShell } from './base';
+NCoreInitShell();
--- a/packages/napcat-shell/package.json
+++ b/packages/napcat-shell/package.json
@@ -0,0 +1,31 @@
+{
+    "name": "napcat-shell",
+    "version": "0.0.1",
+    "private": true,
+    "type": "module",
+    "main": "index.ts",
+    "scripts": {
+        "build": "vite build"
+    },
+    "exports": {
+        ".": {
+            "import": "./index.ts"
+        },
+        "./*": {
+            "import": "./*"
+        }
+    },
+    "dependencies": {
+        "napcat-core": "workspace:*",
+        "napcat-common": "workspace:*",
+        "napcat-onebot": "workspace:*",
+        "napcat-webui-backend": "workspace:*",
+        "napcat-qrcode": "workspace:*"
+    },
+    "devDependencies": {
+        "@types/node": "^22.0.1"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}
--- a/packages/napcat-shell/pipe.ts
+++ b/packages/napcat-shell/pipe.ts
@@ -0,0 +1,122 @@
+import { LogWrapper } from 'napcat-common/src/log';
+import * as net from 'net';
+import * as process from 'process';
+import { Writable } from 'stream';
+
+/**
+ * 连接到命名管道并重定向stdout
+ * @param logger 日志记录器
+ * @param timeoutMs 连接超时时间(毫秒)，默认5000ms
+ * @returns Promise，连接成功时resolve，失败时reject
+ */
+export function connectToNamedPipe (logger: LogWrapper, timeoutMs: number = 5000): Promise<{ disconnect: () => void }> {
+  return new Promise((resolve, reject) => {
+    if (process.platform !== 'win32') {
+      // 非Windows平台不reject，而是返回一个空的disconnect函数
+      return resolve({ disconnect: () => { } });
+    }
+
+    const pid = process.pid;
+    const pipePath = `\\\\.\\pipe\\NapCat_${pid}`;
+
+    // 设置连接超时
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`连接命名管道超时: ${pipePath}`));
+    }, timeoutMs);
+
+    try {
+      const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+      const pipeSocket = net.connect(pipePath, () => {
+        // 清除超时
+        clearTimeout(timeoutId);
+
+        // 优化网络性能设置
+        pipeSocket.setNoDelay(true); // 减少延迟
+
+        // 设置更高的高水位线，允许更多数据缓冲
+
+        logger.log(`[StdOut] 已重定向到命名管道: ${pipePath}`);
+
+        // 创建拥有更优雅背压处理的 Writable 流
+        const pipeWritable = new Writable({
+          highWaterMark: 1024 * 64, // 64KB 高水位线
+          write (chunk, encoding, callback) {
+            if (!pipeSocket.writable) {
+              // 如果管道不可写，退回到原始stdout
+              logger.log('[StdOut] 管道不可写，回退到控制台输出');
+              return originalStdoutWrite(chunk, encoding, callback);
+            }
+
+            // 尝试写入数据到管道
+            const canContinue = pipeSocket.write(chunk, encoding, () => {
+              // 数据已被发送或放入内部缓冲区
+            });
+
+            if (canContinue) {
+              // 如果返回true，表示可以继续写入更多数据
+              // 立即通知写入流可以继续
+              process.nextTick(callback);
+            } else {
+              // 如果返回false，表示内部缓冲区已满
+              // 等待drain事件再恢复写入
+              pipeSocket.once('drain', () => {
+                callback();
+              });
+            }
+            // 明确返回true，表示写入已处理
+            return true;
+          },
+        });
+
+        // 重定向stdout
+        process.stdout.write = (
+          chunk: any,
+          encoding?: BufferEncoding | (() => void),
+          cb?: () => void
+        ): boolean => {
+          if (typeof encoding === 'function') {
+            cb = encoding;
+            encoding = undefined;
+          }
+
+          // 使用优化的writable流处理写入
+          return pipeWritable.write(chunk, encoding as BufferEncoding, cb as () => void);
+        };
+
+        // 提供断开连接的方法
+        const disconnect = () => {
+          process.stdout.write = originalStdoutWrite;
+          pipeSocket.end();
+          logger.log(`已手动断开命名管道连接: ${pipePath}`);
+        };
+
+        // 返回成功和断开连接的方法
+        resolve({ disconnect });
+      });
+
+      // 管道错误处理
+      pipeSocket.on('error', (err) => {
+        clearTimeout(timeoutId);
+        process.stdout.write = originalStdoutWrite;
+        logger.log(`连接命名管道 ${pipePath} 时出错:`, err);
+        reject(err);
+      });
+
+      // 管道关闭处理
+      pipeSocket.on('end', () => {
+        process.stdout.write = originalStdoutWrite;
+        logger.log('命名管道连接已关闭');
+      });
+
+      // 确保在连接意外关闭时恢复stdout
+      pipeSocket.on('close', () => {
+        process.stdout.write = originalStdoutWrite;
+        logger.log('命名管道连接已关闭');
+      });
+    } catch (error) {
+      clearTimeout(timeoutId);
+      logger.log(`尝试连接命名管道 ${pipePath} 时发生异常:`, error);
+      reject(error);
+    }
+  });
+}
--- a/packages/napcat-shell/tsconfig.json
+++ b/packages/napcat-shell/tsconfig.json
@@ -0,0 +1,49 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "lib": [
+      "ES2021"
+    ],
+    "typeRoots": [
+      "./node_modules/@types"
+    ],
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "noEmit": false,
+    "sourceMap": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "alwaysStrict": true,
+    "noImplicitThis": true,
+    "noImplicitReturns": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "useUnknownInCatchVariables": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "useDefineForClassFields": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "baseUrl": ".",
+    "skipLibCheck": true,
+    "skipDefaultLibCheck": true
+  },
+  "include": [
+    "*.ts",
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}
--- a/packages/napcat-shell/vite.config.ts
+++ b/packages/napcat-shell/vite.config.ts
@@ -0,0 +1,61 @@
+import cp from 'vite-plugin-cp';
+import { defineConfig, PluginOption, UserConfig } from 'vite';
+import path, { resolve } from 'path';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import { builtinModules } from 'module';
+//依赖排除
+const external = [
+  'silk-wasm',
+  'ws',
+  'express'
+];
+const nodeModules = [...builtinModules, builtinModules.map((m) => `node:${m}`)].flat();
+const ShellBaseConfigPlugin: PluginOption[] = [
+  cp({
+    targets: [
+      { src: '../napcat-native/', dest: 'dist/native', flatten: false },
+      { src: '../napcat-webui-frontend/dist/', dest: 'dist/static/', flatten: false },
+      { src: '../napcat-core/external/napcat.json', dest: 'dist/config/' },
+      { src: '../../package.json', dest: 'dist' },
+      { src: '../napcat-shell-loader', dest: 'dist' }
+    ],
+  }),
+  nodeResolve(),
+];
+const ShellBaseConfig = () =>
+  defineConfig({
+    resolve: {
+      conditions: ['node', 'default'],
+      alias: {
+        '@/napcat-core': resolve(__dirname, '../napcat-core'),
+        '@/napcat-common': resolve(__dirname, '../napcat-common/src'),
+        '@/napcat-onebot': resolve(__dirname, '../napcat-onebot'),
+        '@/napcat-pty': resolve(__dirname, '../napcat-pty'),
+        '@/napcat-webui-backend': resolve(__dirname, '../napcat-webui-backend/src'),
+        '@/image-size': resolve(__dirname, '../image-size'),
+      },
+    },
+    build: {
+      sourcemap: false,
+      target: 'esnext',
+      minify: false,
+      lib: {
+        entry: {
+          napcat: path.resolve(__dirname, 'napcat.ts'),
+          'audio-worker': path.resolve(__dirname, '../napcat-common/src/audio-worker.ts'),
+          'worker/conoutSocketWorker': path.resolve(__dirname, '../napcat-pty/worker/conoutSocketWorker.ts'),
+        },
+        formats: ['es'],
+        fileName: (_, entryName) => `${entryName}.mjs`,
+      },
+      rollupOptions: {
+        external: [...nodeModules, ...external],
+      },
+    },
+  });
+export default defineConfig((): UserConfig => {
+  return {
+    ...ShellBaseConfig(),
+    plugins: [...ShellBaseConfigPlugin],
+  };
+});