Update OpenRouter model in release workflow

Changed the OPENROUTER_MODEL environment variable in the release workflow to use 'copilot/gemini-3-flash-preview' instead of 'copilot/ant/gemini-3-flash-preview'.

.github/prompt/default.md

@@ -1,4 +1,4 @@
-# V?.?.?
+# {VERSION}
 [使用文档](https://napneko.github.io/)
 
 ## Windows 一键包
@@ -15,13 +15,29 @@ NapCat.Shell.Windows.OneKey.zip (无头)
 **注意QQ版本推荐使用 40768+ 版本 最低可以使用40768版本**
 **默认WebUi密钥为随机密码 控制台查看**
 
-**[9.9.22-40990 X64 Win](https://dldir1v6.qq.com/qqfile/qq/QQNT/2c9d3f6c/QQ9.9.22.40990_x64.exe)**
-[LinuxX64 DEB 40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_amd64.deb)
-[LinuxX64 RPM 40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_x86_64.rpm)
-[LinuxArm64 DEB 40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_arm64.deb)
-[LinuxArm64 RPM  40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_aarch64.rpm)
+**[9.9.26-44343 X64 Win](https://dldir1.qq.com/qqfile/qq/QQNT/40d6045a/QQ9.9.26.44343_x64.exe)**
+[LinuxX64 DEB 44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_amd64.deb)
+[LinuxX64 RPM 44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_x86_64.rpm)
+[LinuxArm64 DEB 44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_arm64.deb)
+[LinuxArm64 RPM  44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_aarch64.rpm)
 [MAC   DMG   40990 ](https://dldir1v6.qq.com/qqfile/qq/QQNT/c6cb0f5d/QQ_v6.9.82.40990.dmg)
 ## 如果WinX64缺少运行库或者xxx.dll？
 [安装运行库](https://aka.ms/vs/17/release/vc_redist.x64.exe)
 
 ## 更新
+
+### 🐛 修复
+1. 修复 WebUI 主题配置在有未保存更改时卸载组件导致字体重置的问题 (ae42eed6)
+
+### ✨ 新增
+1. 文件上传相关接口（UploadGroupFile/UploadPrivateFile）新增 `upload_file` 参数支持 (91e0839e)
+2. 消息发送逻辑支持 PTT（语音）元素过滤，确保语音消息正确独立发送 (47983e29)
+
+### 🔧 优化
+1. 优化合并转发消息（GetForwardMsg）的获取与解析逻辑，提高兼容性 (334c4233)
+2. 改进消息发送方法中发送者 UIN 的处理逻辑 (71bb4f68)
+3. 增强 WebUI 系统信息界面中对构建产物的处理与展示 (cb061890)
+
+---
+
+**完整更新日志**: [v4.10.6...v4.10.7](https://github.com/NapNeko/NapCatQQ/compare/v4.10.6...v4.10.7)

.github/prompt/release_note_prompt.txt

@@ -1,34 +1,33 @@
-注意：输出必须严格使用 NapCat 的发布说明格式，严格保证示例格式,并用简体中文。
+# NapCat Release Note Generator
 
-格式规则：
-1. 第一行：# V{TAG}  
-2. 第二行：[使用文档](https://napneko.github.io/)
-3. 空行后，按下面的节顺序输出（存在则输出，不存在则省略该节）：
+你是 NapCat 项目的发布说明生成器。请根据提供的 commit 列表生成标准格式的发布说明。
 
-## Windows 一键包
-- 简短一句话介绍一键包用途
-- 列出可下载的文件名（只列文件名，不写下载链接）
+## 核心规则
 
-## 警告
-- 如果有需要特别提醒的兼容/运行库/版本要求，写成加粗警告句
+1. **版本号**：第一行必须是 `# {VERSION}`，使用用户提供的版本号，如果版本号是小写 v 开头（如 v4.10.2），必须转换为大写 V（如 V4.10.2）
+2. **语言**：全部使用简体中文
+3. **格式**：严格按照下方模板输出，不要添加额外的 markdown 格式
 
-## 如果WinX64缺少运行库或者xxx.dll？
-- 常见运行库建议
+## Commit 分析规则
 
-## 更新
-按数字序列列出主要变更项，每条尽量一句话
-- 前缀短 commit id，例如：1. 修复 get_essence_msg_list 崩溃 (a1b2c3d)
-- 保持 4-18 条要点
+将 commit 分类为以下类型：
+- 🐛 **修复**：bug fix、修复、fix 相关
+- ✨ **新增**：新功能、feat、add 相关  
+- 🔧 **优化**：优化、重构、refactor、improve、perf 相关
+- 📦 **依赖**：deps、依赖更新（通常可以忽略或合并）
+- 🔨 **构建**：ci、build、workflow 相关（通常可以忽略）
 
-## 开发者注意
-- 列出迁移/接口断裂/配置变更；若无则省略
+## 合并和筛选
 
-额外约束：
-- 语言简体中文，面向最终用户
+- **合并相似项**：同一功能的多个 commit 合并为一条
+- **忽略琐碎项**：合并冲突、格式化、typo 等可忽略
+- **控制数量**：最终保持 5-15 条更新要点
+- **保留 commit hash**：每条末尾附上短 hash，格式 `(a1b2c3d)`
 
-下面为真实示例，请完全参考（第一行版本号必须使用用户提供的版本号，例如 v4.9.5）
+## 输出模板 - 必须严格遵守以下格式
 
-# V4.9.0
+```
+# {VERSION}
 [使用文档](https://napneko.github.io/)
 
 ## Windows 一键包
@@ -45,16 +44,68 @@ NapCat.Shell.Windows.OneKey.zip (无头)
 **注意QQ版本推荐使用 40768+ 版本 最低可以使用40768版本**
 **默认WebUi密钥为随机密码 控制台查看**
 
-**[9.9.22-40990 X64 Win](https://dldir1v6.qq.com/qqfile/qq/QQNT/2c9d3f6c/QQ9.9.22.40990_x64.exe)**
-[LinuxX64 DEB 40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_amd64.deb)
-[LinuxX64 RPM 40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_x86_64.rpm)
-[LinuxArm64 DEB 40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_arm64.deb)
-[LinuxArm64 RPM  40990 ](https://dldir1.qq.com/qqfile/qq/QQNT/ec800879/linuxqq_3.2.20-40990_aarch64.rpm)
+**[9.9.26-44343 X64 Win](https://dldir1.qq.com/qqfile/qq/QQNT/40d6045a/QQ9.9.26.44343_x64.exe)**
+[LinuxX64 DEB 44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_amd64.deb)
+[LinuxX64 RPM 44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_x86_64.rpm)
+[LinuxArm64 DEB 44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_arm64.deb)
+[LinuxArm64 RPM  44343 ](https://dldir1.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_aarch64.rpm)
 [MAC   DMG   40990 ](https://dldir1v6.qq.com/qqfile/qq/QQNT/c6cb0f5d/QQ_v6.9.82.40990.dmg)
 ## 如果WinX64缺少运行库或者xxx.dll？
 [安装运行库](https://aka.ms/vs/17/release/vc_redist.x64.exe)
 
 ## 更新
-1. 修改了XXXXX
-2. 新增了XXXX
-3. 重构了XXXX
+
+### 🐛 修复
+1. 修复 xxx 问题 (a1b2c3d)
+2. 修复 yyy 崩溃 (b2c3d4e)
+
+### ✨ 新增
+1. 新增 xxx 功能 (c3d4e5f)
+2. 支持 yyy 特性 (d4e5f6g)
+
+### 🔧 优化
+1. 优化 xxx 性能 (e5f6g7h)
+2. 重构 yyy 模块 (f6g7h8i)
+
+---
+
+**完整更新日志**: [{PREV_VERSION}...{VERSION}](https://github.com/NapNeko/NapCatQQ/compare/{PREV_VERSION}...{VERSION})
+```
+
+**格式要求 - 务必严格遵守：**
+- "Windows 一键包"部分的文本必须完全一致，不要修改任何措辞
+- "警告"部分必须包含所有 QQ 版本下载链接，保持原有格式
+- "如果WinX64缺少运行库或者xxx.dll？"这一行必须保持原样
+- QQ 版本号和下载链接保持不变（40990 版本）
+- 只有"## 更新"部分下面的内容需要根据实际 commit 生成
+
+## 重要约束
+
+1. 如果某个分类没有内容，则完全省略该分类
+2. 不要编造不存在的更新
+3. 保持简洁，每条更新控制在一行内
+4. 使用用户友好的语言，避免过于技术化的描述
+5. 重大变更（Breaking Changes）需要在注意事项中加粗提示
+
+## 文件变化分析
+
+用户会提供文件变化统计和具体代码diff，帮助你理解变更内容：
+
+### 目录含义
+- `packages/napcat-core/` → 核心功能、消息处理、QQ接口
+- `packages/napcat-onebot/` → OneBot 协议实现、API、事件
+- `packages/napcat-webui-backend/` → WebUI 后端接口
+- `packages/napcat-webui-frontend/` → WebUI 前端界面
+- `packages/napcat-shell/` → Shell 启动器
+
+### 代码diff阅读指南
+- `+` 开头的行是新增代码
+- `-` 开头的行是删除代码
+- 关注函数名、类名的变化来理解功能变更
+- 关注 `fix`、`bug`、`error` 等关键词识别修复项
+- 关注 `add`、`new`、`feature` 等关键词识别新功能
+- 忽略纯重构（代码移动但功能不变）和格式化变更
+
+### 截断说明
+- 如果看到 `[... 已截断 ...]`，表示内容过长被截断
+- 根据已有信息推断完整变更意图即可

.github/scripts/lib/comment.ts

@@ -0,0 +1,231 @@
+/**
+ * 构建状态评论模板
+ */
+
+export const COMMENT_MARKER = '<!-- napcat-pr-build -->';
+
+export type BuildStatus = 'success' | 'failure' | 'cancelled' | 'pending' | 'unknown';
+
+export interface BuildTarget {
+  name: string;
+  status: BuildStatus;
+  error?: string;
+  downloadUrl?: string;  // Artifact 直接下载链接
+}
+
+// ============== 辅助函数 ==============
+
+function formatSha (sha: string): string {
+  return sha && sha.length >= 7 ? sha.substring(0, 7) : sha || 'unknown';
+}
+
+function escapeCodeBlock (text: string): string {
+  // 替换 ``` 为转义形式，避免破坏 Markdown 代码块
+  return text.replace(/```/g, '\\`\\`\\`');
+}
+
+function getTimeString (): string {
+  return new Date().toISOString().replace('T', ' ').substring(0, 19) + ' UTC';
+}
+
+// ============== 状态图标 ==============
+
+export function getStatusIcon (status: BuildStatus): string {
+  switch (status) {
+    case 'success':
+      return '✅ 成功';
+    case 'pending':
+      return '⏳ 构建中...';
+    case 'cancelled':
+      return '⚪ 已取消';
+    case 'failure':
+      return '❌ 失败';
+    default:
+      return '❓ 未知';
+  }
+}
+
+function getStatusEmoji (status: BuildStatus): string {
+  switch (status) {
+    case 'success': return '✅';
+    case 'pending': return '⏳';
+    case 'cancelled': return '⚪';
+    case 'failure': return '❌';
+    default: return '❓';
+  }
+}
+
+// ============== 构建中评论 ==============
+
+export function generateBuildingComment (prSha: string, targets: string[]): string {
+  const time = getTimeString();
+  const shortSha = formatSha(prSha);
+
+  const lines: string[] = [
+    COMMENT_MARKER,
+    '',
+    '<div align="center">',
+    '',
+    '# 🔨 NapCat 构建中',
+    '',
+    '![Building](https://img.shields.io/badge/状态-构建中-yellow?style=for-the-badge&logo=github-actions&logoColor=white)',
+    '',
+    '</div>',
+    '',
+    '---',
+    '',
+    '## 📦 构建目标',
+    '',
+    '| 包名 | 状态 | 说明 |',
+    '| :--- | :---: | :--- |',
+    ...targets.map(name => `| \`${name}\` | ⏳ | 正在构建... |`),
+    '',
+    '---',
+    '',
+    '## 📋 构建信息',
+    '',
+    `| 项目 | 值 |`,
+    `| :--- | :--- |`,
+    `| 📝 提交 | \`${shortSha}\` |`,
+    `| 🕐 开始时间 | ${time} |`,
+    '',
+    '---',
+    '',
+    '<div align="center">',
+    '',
+    '> ⏳ **构建进行中，请稍候...**',
+    '>',
+    '> 构建完成后将自动更新此评论',
+    '',
+    '</div>',
+  ];
+
+  return lines.join('\n');
+}
+
+// ============== 构建结果评论 ==============
+
+export function generateResultComment (
+  targets: BuildTarget[],
+  prSha: string,
+  runId: string,
+  repository: string,
+  version?: string
+): string {
+  const runUrl = `https://github.com/${repository}/actions/runs/${runId}`;
+  const shortSha = formatSha(prSha);
+  const time = getTimeString();
+
+  const allSuccess = targets.every(t => t.status === 'success');
+  const anyCancelled = targets.some(t => t.status === 'cancelled');
+  const anyFailure = targets.some(t => t.status === 'failure');
+
+  // 状态徽章
+  let statusBadge: string;
+  let headerTitle: string;
+  if (allSuccess) {
+    statusBadge = '![Success](https://img.shields.io/badge/状态-构建成功-success?style=for-the-badge&logo=github-actions&logoColor=white)';
+    headerTitle = '# ✅ NapCat 构建成功';
+  } else if (anyCancelled && !anyFailure) {
+    statusBadge = '![Cancelled](https://img.shields.io/badge/状态-已取消-lightgrey?style=for-the-badge&logo=github-actions&logoColor=white)';
+    headerTitle = '# ⚪ NapCat 构建已取消';
+  } else {
+    statusBadge = '![Failed](https://img.shields.io/badge/状态-构建失败-critical?style=for-the-badge&logo=github-actions&logoColor=white)';
+    headerTitle = '# ❌ NapCat 构建失败';
+  }
+
+  const downloadLink = (target: BuildTarget) => {
+    if (target.status !== 'success') return '—';
+    if (target.downloadUrl) {
+      return `[📥 下载](${target.downloadUrl})`;
+    }
+    return `[📥 下载](${runUrl}#artifacts)`;
+  };
+
+  const lines: string[] = [
+    COMMENT_MARKER,
+    '',
+    '<div align="center">',
+    '',
+    headerTitle,
+    '',
+    statusBadge,
+    '',
+    '</div>',
+    '',
+    '---',
+    '',
+    '## 📦 构建产物',
+    '',
+    '| 包名 | 状态 | 下载 |',
+    '| :--- | :---: | :---: |',
+    ...targets.map(t => `| \`${t.name}\` | ${getStatusEmoji(t.status)} ${t.status === 'success' ? '成功' : t.status === 'failure' ? '失败' : t.status === 'cancelled' ? '已取消' : '未知'} | ${downloadLink(t)} |`),
+    '',
+    '---',
+    '',
+    '## 📋 构建信息',
+    '',
+    `| 项目 | 值 |`,
+    `| :--- | :--- |`,
+    ...(version ? [`| 🏷️ 版本号 | \`${version}\` |`] : []),
+    `| 📝 提交 | \`${shortSha}\` |`,
+    `| 🔗 构建日志 | [查看详情](${runUrl}) |`,
+    `| 🕐 完成时间 | ${time} |`,
+  ];
+
+  // 添加错误详情
+  const failedTargets = targets.filter(t => t.status === 'failure' && t.error);
+  if (failedTargets.length > 0) {
+    lines.push('', '---', '', '## ⚠️ 错误详情', '');
+    for (const target of failedTargets) {
+      lines.push(
+        `<details>`,
+        `<summary>🔴 <b>${target.name}</b> 构建错误</summary>`,
+        '',
+        '```',
+        escapeCodeBlock(target.error!),
+        '```',
+        '',
+        '</details>',
+        ''
+      );
+    }
+  }
+
+  // 添加底部提示
+  lines.push('---', '');
+  if (allSuccess) {
+    lines.push(
+      '<div align="center">',
+      '',
+      '> 🎉 **所有构建均已成功完成！**',
+      '>',
+      '> 点击上方下载链接获取构建产物进行测试',
+      '',
+      '</div>'
+    );
+  } else if (anyCancelled && !anyFailure) {
+    lines.push(
+      '<div align="center">',
+      '',
+      '> ⚪ **构建已被取消**',
+      '>',
+      '> 可能是由于新的提交触发了新的构建',
+      '',
+      '</div>'
+    );
+  } else {
+    lines.push(
+      '<div align="center">',
+      '',
+      '> ⚠️ **部分构建失败**',
+      '>',
+      '> 请查看上方错误详情或点击构建日志查看完整输出',
+      '',
+      '</div>'
+    );
+  }
+
+  return lines.join('\n');
+}
+

.github/scripts/lib/github.ts

@@ -0,0 +1,189 @@
+/**
+ * GitHub API 工具库
+ */
+
+import { appendFileSync } from 'node:fs';
+
+// ============== 类型定义 ==============
+
+export interface PullRequest {
+  number: number;
+  state: string;
+  head: {
+    sha: string;
+    ref: string;
+    repo: {
+      full_name: string;
+    };
+  };
+}
+
+export interface Repository {
+  owner: {
+    type: string;
+  };
+}
+
+export interface Artifact {
+  id: number;
+  name: string;
+  size_in_bytes: number;
+  archive_download_url: string;
+}
+
+// ============== GitHub API Client ==========================
+
+export class GitHubAPI {
+  private token: string;
+  private baseUrl = 'https://api.github.com';
+
+  constructor (token: string) {
+    this.token = token;
+  }
+
+  private async request<T> (endpoint: string, options: RequestInit = {}): Promise<T> {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
+      ...options,
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        Accept: 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`GitHub API error: ${response.status} ${response.statusText}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async getPullRequest (owner: string, repo: string, pullNumber: number): Promise<PullRequest> {
+    return this.request<PullRequest>(`/repos/${owner}/${repo}/pulls/${pullNumber}`);
+  }
+
+  async getCollaboratorPermission (owner: string, repo: string, username: string): Promise<string> {
+    const data = await this.request<{ permission: string; }>(
+      `/repos/${owner}/${repo}/collaborators/${username}/permission`
+    );
+    return data.permission;
+  }
+
+  async getRepository (owner: string, repo: string): Promise<Repository> {
+    return this.request(`/repos/${owner}/${repo}`);
+  }
+
+  async checkOrgMembership (org: string, username: string): Promise<boolean> {
+    try {
+      await this.request(`/orgs/${org}/members/${username}`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async getRunArtifacts (owner: string, repo: string, runId: string): Promise<Artifact[]> {
+    const data = await this.request<{ artifacts: Artifact[]; }>(
+      `/repos/${owner}/${repo}/actions/runs/${runId}/artifacts`
+    );
+    return data.artifacts;
+  }
+
+  async createComment (owner: string, repo: string, issueNumber: number, body: string): Promise<void> {
+    await this.request(`/repos/${owner}/${repo}/issues/${issueNumber}/comments`, {
+      method: 'POST',
+      body: JSON.stringify({ body }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  async findComment (owner: string, repo: string, issueNumber: number, marker: string): Promise<number | null> {
+    let page = 1;
+    const perPage = 100;
+
+    while (page <= 10) { // 最多检查 1000 条评论
+      const comments = await this.request<Array<{ id: number, body: string; }>>(
+        `/repos/${owner}/${repo}/issues/${issueNumber}/comments?per_page=${perPage}&page=${page}`
+      );
+
+      if (comments.length === 0) {
+        return null;
+      }
+
+      const found = comments.find(c => c.body.includes(marker));
+      if (found) {
+        return found.id;
+      }
+
+      if (comments.length < perPage) {
+        return null;
+      }
+
+      page++;
+    }
+
+    return null;
+  }
+
+  async updateComment (owner: string, repo: string, commentId: number, body: string): Promise<void> {
+    await this.request(`/repos/${owner}/${repo}/issues/comments/${commentId}`, {
+      method: 'PATCH',
+      body: JSON.stringify({ body }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  async createOrUpdateComment (
+    owner: string,
+    repo: string,
+    issueNumber: number,
+    body: string,
+    marker: string
+  ): Promise<void> {
+    const existingId = await this.findComment(owner, repo, issueNumber, marker);
+    if (existingId) {
+      await this.updateComment(owner, repo, existingId, body);
+      console.log(`✓ Updated comment #${existingId}`);
+    } else {
+      await this.createComment(owner, repo, issueNumber, body);
+      console.log('✓ Created new comment');
+    }
+  }
+}
+
+// ============== Output 工具 ==============
+
+export function setOutput (name: string, value: string): void {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    appendFileSync(outputFile, `${name}=${value}\n`);
+  }
+  console.log(`  ${name}=${value}`);
+}
+
+export function setMultilineOutput (name: string, value: string): void {
+  const outputFile = process.env.GITHUB_OUTPUT;
+  if (outputFile) {
+    const delimiter = `EOF_${Date.now()}`;
+    appendFileSync(outputFile, `${name}<<${delimiter}\n${value}\n${delimiter}\n`);
+  }
+}
+
+// ============== 环境变量工具 ==============
+
+export function getEnv (name: string, required: true): string;
+export function getEnv (name: string, required?: false): string | undefined;
+export function getEnv (name: string, required = false): string | undefined {
+  const value = process.env[name];
+  if (required && !value) {
+    throw new Error(`Environment variable ${name} is required`);
+  }
+  return value;
+}
+
+export function getRepository (): { owner: string, repo: string; } {
+  const repository = getEnv('GITHUB_REPOSITORY', true);
+  const [owner, repo] = repository.split('/');
+  return { owner, repo };
+}

.github/scripts/pr-build-building.ts

@@ -0,0 +1,36 @@
+/**
+ * PR Build - 更新构建中状态评论
+ *
+ * 环境变量:
+ * - GITHUB_TOKEN: GitHub API Token
+ * - PR_NUMBER: PR 编号
+ * - PR_SHA: PR 提交 SHA
+ */
+
+import { GitHubAPI, getEnv, getRepository } from './lib/github.ts';
+import { generateBuildingComment, COMMENT_MARKER } from './lib/comment.ts';
+
+const BUILD_TARGETS = ['NapCat.Framework', 'NapCat.Shell'];
+
+async function main (): Promise<void> {
+  console.log('🔨 Updating building status comment\n');
+
+  const token = getEnv('GITHUB_TOKEN', true);
+  const prNumber = parseInt(getEnv('PR_NUMBER', true), 10);
+  const prSha = getEnv('PR_SHA', true);
+  const { owner, repo } = getRepository();
+
+  console.log(`PR: #${prNumber}`);
+  console.log(`SHA: ${prSha}`);
+  console.log(`Repo: ${owner}/${repo}\n`);
+
+  const github = new GitHubAPI(token);
+  const comment = generateBuildingComment(prSha, BUILD_TARGETS);
+
+  await github.createOrUpdateComment(owner, repo, prNumber, comment, COMMENT_MARKER);
+}
+
+main().catch((error) => {
+  console.error('❌ Error:', error);
+  process.exit(1);
+});

.github/scripts/pr-build-check.ts

@@ -0,0 +1,206 @@
+/**
+ * PR Build Check Script
+ * 检查 PR 构建触发条件和用户权限
+ *
+ * 环境变量:
+ * - GITHUB_TOKEN: GitHub API Token
+ * - GITHUB_EVENT_NAME: 事件名称
+ * - GITHUB_EVENT_PATH: 事件 payload 文件路径
+ * - GITHUB_REPOSITORY: 仓库名称 (owner/repo)
+ * - GITHUB_OUTPUT: 输出文件路径
+ */
+
+import { readFileSync } from 'node:fs';
+import { GitHubAPI, getEnv, getRepository, setOutput } from './lib/github.ts';
+import type { PullRequest } from './lib/github.ts';
+
+// ============== 类型定义 ==============
+
+interface GitHubPayload {
+  pull_request?: PullRequest;
+  issue?: {
+    number: number;
+    pull_request?: object;
+  };
+  comment?: {
+    body: string;
+    user: { login: string; };
+  };
+}
+
+interface CheckResult {
+  should_build: boolean;
+  pr_number?: number;
+  pr_sha?: string;
+  pr_head_repo?: string;
+  pr_head_ref?: string;
+}
+
+// ============== 权限检查 ==============
+
+async function checkUserPermission (
+  github: GitHubAPI,
+  owner: string,
+  repo: string,
+  username: string
+): Promise<boolean> {
+  // 方法1：检查仓库协作者权限
+  try {
+    const permission = await github.getCollaboratorPermission(owner, repo, username);
+    if (['admin', 'write', 'maintain'].includes(permission)) {
+      console.log(`✓ User ${username} has ${permission} permission`);
+      return true;
+    }
+    console.log(`✗ User ${username} has ${permission} permission (insufficient)`);
+  } catch (e) {
+    console.log(`✗ Failed to get collaborator permission: ${(e as Error).message}`);
+  }
+
+  // 方法2：检查组织成员身份
+  try {
+    const repoInfo = await github.getRepository(owner, repo);
+    if (repoInfo.owner.type === 'Organization') {
+      const isMember = await github.checkOrgMembership(owner, username);
+      if (isMember) {
+        console.log(`✓ User ${username} is organization member`);
+        return true;
+      }
+      console.log(`✗ User ${username} is not organization member`);
+    }
+  } catch (e) {
+    console.log(`✗ Failed to check org membership: ${(e as Error).message}`);
+  }
+
+  return false;
+}
+
+// ============== 事件处理 ==============
+
+function handlePullRequestTarget (payload: GitHubPayload): CheckResult {
+  const pr = payload.pull_request;
+
+  if (!pr) {
+    console.log('✗ No pull_request in payload');
+    return { should_build: false };
+  }
+
+  if (pr.state !== 'open') {
+    console.log(`✗ PR is not open (state: ${pr.state})`);
+    return { should_build: false };
+  }
+
+  console.log(`✓ PR #${pr.number} is open, triggering build`);
+  return {
+    should_build: true,
+    pr_number: pr.number,
+    pr_sha: pr.head.sha,
+    pr_head_repo: pr.head.repo.full_name,
+    pr_head_ref: pr.head.ref,
+  };
+}
+
+async function handleIssueComment (
+  payload: GitHubPayload,
+  github: GitHubAPI,
+  owner: string,
+  repo: string
+): Promise<CheckResult> {
+  const { issue, comment } = payload;
+
+  if (!issue || !comment) {
+    console.log('✗ No issue or comment in payload');
+    return { should_build: false };
+  }
+
+  // 检查是否是 PR 的评论
+  if (!issue.pull_request) {
+    console.log('✗ Comment is not on a PR');
+    return { should_build: false };
+  }
+
+  // 检查是否是 /build 命令
+  if (!comment.body.trim().startsWith('/build')) {
+    console.log('✗ Comment is not a /build command');
+    return { should_build: false };
+  }
+
+  console.log(`→ /build command from @${comment.user.login}`);
+
+  // 获取 PR 详情
+  const pr = await github.getPullRequest(owner, repo, issue.number);
+
+  // 检查 PR 状态
+  if (pr.state !== 'open') {
+    console.log(`✗ PR is not open (state: ${pr.state})`);
+    await github.createComment(owner, repo, issue.number, '⚠️ 此 PR 已关闭，无法触发构建。');
+    return { should_build: false };
+  }
+
+  // 检查用户权限
+  const username = comment.user.login;
+  const hasPermission = await checkUserPermission(github, owner, repo, username);
+
+  if (!hasPermission) {
+    console.log(`✗ User ${username} has no permission`);
+    await github.createComment(
+      owner,
+      repo,
+      issue.number,
+      `⚠️ @${username} 您没有权限使用 \`/build\` 命令，仅仓库协作者或组织成员可使用。`
+    );
+    return { should_build: false };
+  }
+
+  console.log(`✓ Build triggered by @${username}`);
+  return {
+    should_build: true,
+    pr_number: issue.number,
+    pr_sha: pr.head.sha,
+    pr_head_repo: pr.head.repo.full_name,
+    pr_head_ref: pr.head.ref,
+  };
+}
+
+// ============== 主函数 ==============
+
+async function main (): Promise<void> {
+  console.log('🔍 PR Build Check\n');
+
+  const token = getEnv('GITHUB_TOKEN', true);
+  const eventName = getEnv('GITHUB_EVENT_NAME', true);
+  const eventPath = getEnv('GITHUB_EVENT_PATH', true);
+  const { owner, repo } = getRepository();
+
+  console.log(`Event: ${eventName}`);
+  console.log(`Repository: ${owner}/${repo}\n`);
+
+  const payload = JSON.parse(readFileSync(eventPath, 'utf-8')) as GitHubPayload;
+  const github = new GitHubAPI(token);
+
+  let result: CheckResult;
+
+  switch (eventName) {
+    case 'pull_request_target':
+      result = handlePullRequestTarget(payload);
+      break;
+    case 'issue_comment':
+      result = await handleIssueComment(payload, github, owner, repo);
+      break;
+    default:
+      console.log(`✗ Unsupported event: ${eventName}`);
+      result = { should_build: false };
+  }
+
+  // 输出结果
+  console.log('\n=== Outputs ===');
+  setOutput('should_build', String(result.should_build));
+  setOutput('pr_number', String(result.pr_number ?? ''));
+  setOutput('pr_sha', result.pr_sha ?? '');
+  setOutput('pr_head_repo', result.pr_head_repo ?? '');
+  setOutput('pr_head_ref', result.pr_head_ref ?? '');
+}
+
+main().catch((error) => {
+  console.error('❌ Error:', error);
+  process.exit(1);
+});

.github/scripts/pr-build-result.ts

@@ -0,0 +1,90 @@
+/**
+ * PR Build - 更新构建结果评论
+ *
+ * 环境变量:
+ * - GITHUB_TOKEN: GitHub API Token
+ * - PR_NUMBER: PR 编号
+ * - PR_SHA: PR 提交 SHA
+ * - RUN_ID: GitHub Actions Run ID
+ * - NAPCAT_VERSION: 构建版本号
+ * - FRAMEWORK_STATUS: Framework 构建状态
+ * - FRAMEWORK_ERROR: Framework 构建错误信息
+ * - SHELL_STATUS: Shell 构建状态
+ * - SHELL_ERROR: Shell 构建错误信息
+ */
+
+import { GitHubAPI, getEnv, getRepository } from './lib/github.ts';
+import { generateResultComment, COMMENT_MARKER } from './lib/comment.ts';
+import type { BuildTarget, BuildStatus } from './lib/comment.ts';
+
+function parseStatus (value: string | undefined): BuildStatus {
+  if (value === 'success' || value === 'failure' || value === 'cancelled') {
+    return value;
+  }
+  return 'unknown';
+}
+
+async function main (): Promise<void> {
+  console.log('📝 Updating build result comment\n');
+
+  const token = getEnv('GITHUB_TOKEN', true);
+  const prNumber = parseInt(getEnv('PR_NUMBER', true), 10);
+  const prSha = getEnv('PR_SHA') || 'unknown';
+  const runId = getEnv('RUN_ID', true);
+  const version = getEnv('NAPCAT_VERSION') || '';
+  const { owner, repo } = getRepository();
+
+  const frameworkStatus = parseStatus(getEnv('FRAMEWORK_STATUS'));
+  const frameworkError = getEnv('FRAMEWORK_ERROR');
+  const shellStatus = parseStatus(getEnv('SHELL_STATUS'));
+  const shellError = getEnv('SHELL_ERROR');
+
+  console.log(`PR: #${prNumber}`);
+  console.log(`SHA: ${prSha}`);
+  console.log(`Version: ${version}`);
+  console.log(`Run: ${runId}`);
+  console.log(`Framework: ${frameworkStatus}${frameworkError ? ` (${frameworkError})` : ''}`);
+  console.log(`Shell: ${shellStatus}${shellError ? ` (${shellError})` : ''}\n`);
+
+  const github = new GitHubAPI(token);
+  const repository = `${owner}/${repo}`;
+
+  // 获取 artifacts 列表，生成直接下载链接
+  const artifactMap: Record<string, string> = {};
+  try {
+    const artifacts = await github.getRunArtifacts(owner, repo, runId);
+    console.log(`Found ${artifacts.length} artifacts`);
+    for (const artifact of artifacts) {
+      // 生成直接下载链接：https://github.com/{owner}/{repo}/actions/runs/{run_id}/artifacts/{artifact_id}
+      const downloadUrl = `https://github.com/${repository}/actions/runs/${runId}/artifacts/${artifact.id}`;
+      artifactMap[artifact.name] = downloadUrl;
+      console.log(`  - ${artifact.name}: ${downloadUrl}`);
+    }
+  } catch (e) {
+    console.log(`Warning: Failed to get artifacts: ${(e as Error).message}`);
+  }
+
+  const targets: BuildTarget[] = [
+    {
+      name: 'NapCat.Framework',
+      status: frameworkStatus,
+      error: frameworkError,
+      downloadUrl: artifactMap['NapCat.Framework'],
+    },
+    {
+      name: 'NapCat.Shell',
+      status: shellStatus,
+      error: shellError,
+      downloadUrl: artifactMap['NapCat.Shell'],
+    },
+  ];
+
+  const comment = generateResultComment(targets, prSha, runId, repository, version);
+
+  await github.createOrUpdateComment(owner, repo, prNumber, comment, COMMENT_MARKER);
+}
+
+main().catch((error) => {
+  console.error('❌ Error:', error);
+  process.exit(1);
+});

.github/scripts/pr-build-run.ts

@@ -0,0 +1,149 @@
+/**
+ * PR Build Runner
+ * 执行构建步骤
+ *
+ * 用法: node pr-build-run.ts <target>
+ * target: framework | shell
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, renameSync, unlinkSync } from 'node:fs';
+import { setOutput } from './lib/github.ts';
+
+type BuildTarget = 'framework' | 'shell';
+
+interface BuildStep {
+  name: string;
+  command: string;
+  errorMessage: string;
+}
+
+// ============== 构建步骤 ==============
+
+function getCommonSteps (): BuildStep[] {
+  return [
+    {
+      name: 'Install pnpm',
+      command: 'npm i -g pnpm',
+      errorMessage: 'Failed to install pnpm',
+    },
+    {
+      name: 'Install dependencies',
+      command: 'pnpm i',
+      errorMessage: 'Failed to install dependencies',
+    },
+    {
+      name: 'Type check',
+      command: 'pnpm run typecheck',
+      errorMessage: 'Type check failed',
+    },
+    {
+      name: 'Test',
+      command: 'pnpm test',
+      errorMessage: 'Tests failed',
+    },
+    {
+      name: 'Build WebUI',
+      command: 'pnpm --filter napcat-webui-frontend run build',
+      errorMessage: 'WebUI build failed',
+    },
+  ];
+}
+
+function getTargetSteps (target: BuildTarget): BuildStep[] {
+  if (target === 'framework') {
+    return [
+      {
+        name: 'Build Framework',
+        command: 'pnpm run build:framework',
+        errorMessage: 'Framework build failed',
+      },
+    ];
+  }
+  return [
+    {
+      name: 'Build Shell',
+      command: 'pnpm run build:shell',
+      errorMessage: 'Shell build failed',
+    },
+  ];
+}
+
+// ============== 执行器 ==============
+
+function runStep (step: BuildStep): boolean {
+  console.log(`\n::group::${step.name}`);
+  console.log(`> ${step.command}\n`);
+
+  try {
+    execSync(step.command, {
+      stdio: 'inherit',
+      shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/bash',
+    });
+    console.log('::endgroup::');
+    console.log(`✓ ${step.name}`);
+    return true;
+  } catch (_error) {
+    console.log('::endgroup::');
+    console.log(`✗ ${step.name}`);
+    setOutput('error', step.errorMessage);
+    return false;
+  }
+}
+
+function postBuild (target: BuildTarget): void {
+  const srcDir = target === 'framework'
+    ? 'packages/napcat-framework/dist'
+    : 'packages/napcat-shell/dist';
+  const destDir = target === 'framework' ? 'framework-dist' : 'shell-dist';
+
+  console.log(`\n→ Moving ${srcDir} to ${destDir}`);
+
+  if (!existsSync(srcDir)) {
+    throw new Error(`Build output not found: ${srcDir}`);
+  }
+
+  renameSync(srcDir, destDir);
+
+  // Install production dependencies
+  console.log('→ Installing production dependencies');
+  execSync('npm install --omit=dev', {
+    cwd: destDir,
+    stdio: 'inherit',
+    shell: process.platform === 'win32' ? 'cmd.exe' : '/bin/bash',
+  });
+
+  // Remove package-lock.json
+  const lockFile = `${destDir}/package-lock.json`;
+  if (existsSync(lockFile)) {
+    unlinkSync(lockFile);
+  }
+
+  console.log(`✓ Build output ready at ${destDir}`);
+}
+
+// ============== 主函数 ==============
+
+function main (): void {
+  const target = process.argv[2] as BuildTarget;
+
+  if (!target || !['framework', 'shell'].includes(target)) {
+    console.error('Usage: node pr-build-run.ts <framework|shell>');
+    process.exit(1);
+  }
+
+  console.log(`🔨 Building NapCat.${target === 'framework' ? 'Framework' : 'Shell'}\n`);
+
+  const steps = [...getCommonSteps(), ...getTargetSteps(target)];
+
+  for (const step of steps) {
+    if (!runStep(step)) {
+      process.exit(1);
+    }
+  }
+
+  postBuild(target);
+  console.log('\n✅ Build completed successfully!');
+}
+
+main();

.github/workflows/auto-release.yml

@@ -46,8 +46,8 @@ jobs:
         env:
             GH_TOKEN: ${{ secrets.NAPCAT_BUILD }}
             NAPCAT_VERSION: ${{ env.latest_tag }}
-            QQ_VERSION_X86_64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/8015ff90/linuxqq_3.2.21-42086_x86_64.AppImage' # 写死 QQ 版本
-            QQ_VERSION_ARM64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/8015ff90/linuxqq_3.2.21-42086_arm64.AppImage' # 写死 QQ 版本
+            QQ_VERSION_X86_64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_x86_64.AppImage' # 写死 QQ 版本
+            QQ_VERSION_ARM64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_arm64.AppImage' # 写死 QQ 版本
         run: |
             echo "Debug: Triggering Release NapCat AppImage with napcat_version=${NAPCAT_VERSION}, qq_version_x86_64=${QQ_VERSION_X86_64}, qq_version_arm64=${QQ_VERSION_ARM64}"
             curl -X POST \
@@ -72,8 +72,8 @@ jobs:
         env:
             GH_TOKEN: ${{ secrets.NAPCAT_BUILD }}
             NAPCAT_VERSION: ${{ env.latest_tag }}
-            QQ_VERSION_X86_64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/8015ff90/linuxqq_3.2.21-42086_x86_64.AppImage' # 写死 QQ 版本
-            QQ_VERSION_ARM64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/8015ff90/linuxqq_3.2.21-42086_arm64.AppImage' # 写死 QQ 版本
+            QQ_VERSION_X86_64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_x86_64.AppImage' # 写死 QQ 版本
+            QQ_VERSION_ARM64: 'https://dldir1v6.qq.com/qqfile/qq/QQNT/94704804/linuxqq_3.2.23-44343_arm64.AppImage' # 写死 QQ 版本
         run: |
             echo "Debug: Triggering Release NapCat AppImage with napcat_version=${NAPCAT_VERSION}, qq_url_amd64=${QQ_VERSION_X86_64}, qq_url_arm64=${QQ_VERSION_ARM64}"
             curl -X POST \

.github/workflows/build.yml

@@ -13,11 +13,27 @@ jobs:
     steps:
       - name: Clone Main Repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # 需要完整历史来获取 tags
       - name: Use Node.js 20.X
         uses: actions/setup-node@v4
         with:
           node-version: 20.x
+      - name: Generate Version
+        run: |
+          # 获取最近的 release tag (格式: vX.X.X)
+          LATEST_TAG=$(git describe --tags --abbrev=0 --match "v[0-9]*.[0-9]*.[0-9]*" 2>/dev/null || echo "v0.0.0")
+          # 去掉 v 前缀
+          BASE_VERSION="${LATEST_TAG#v}"
+          SHORT_SHA="${GITHUB_SHA::7}"
+          VERSION="${BASE_VERSION}-main.${{ github.run_number }}+${SHORT_SHA}"
+          echo "NAPCAT_VERSION=${VERSION}" >> $GITHUB_ENV
+          echo "Latest tag: ${LATEST_TAG}"
+          echo "Build version: ${VERSION}"
       - name: Build NapCat.Framework
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NAPCAT_VERSION: ${{ env.NAPCAT_VERSION }}
         run: |
           npm i -g pnpm
           pnpm i
@@ -25,6 +41,7 @@ jobs:
           pnpm test || exit 1
           pnpm --filter napcat-webui-frontend run build || exit 1
           pnpm run build:framework
+          pnpm --filter napcat-plugin-builtin run build || exit 1
           mv packages/napcat-framework/dist framework-dist
           cd framework-dist
           npm install --omit=dev
@@ -39,11 +56,27 @@ jobs:
     steps:
       - name: Clone Main Repository
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # 需要完整历史来获取 tags
       - name: Use Node.js 20.X
         uses: actions/setup-node@v4
         with:
           node-version: 20.x
+      - name: Generate Version
+        run: |
+          # 获取最近的 release tag (格式: vX.X.X)
+          LATEST_TAG=$(git describe --tags --abbrev=0 --match "v[0-9]*.[0-9]*.[0-9]*" 2>/dev/null || echo "v0.0.0")
+          # 去掉 v 前缀
+          BASE_VERSION="${LATEST_TAG#v}"
+          SHORT_SHA="${GITHUB_SHA::7}"
+          VERSION="${BASE_VERSION}-main.${{ github.run_number }}+${SHORT_SHA}"
+          echo "NAPCAT_VERSION=${VERSION}" >> $GITHUB_ENV
+          echo "Latest tag: ${LATEST_TAG}"
+          echo "Build version: ${VERSION}"
       - name: Build NapCat.Shell
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NAPCAT_VERSION: ${{ env.NAPCAT_VERSION }}
         run: |
           npm i -g pnpm
           pnpm i
@@ -51,6 +84,7 @@ jobs:
           pnpm test || exit 1
           pnpm --filter napcat-webui-frontend run build || exit 1
           pnpm run build:shell
+          pnpm --filter napcat-plugin-builtin run build || exit 1
           mv packages/napcat-shell/dist shell-dist
           cd shell-dist
           npm install --omit=dev

.github/workflows/pr-build.yml

@@ -0,0 +1,303 @@
+# =============================================================================
+# PR 构建工作流
+# =============================================================================
+# 功能：
+#   1. 在 PR 提交时自动构建 Framework 和 Shell 包
+#   2. 支持通过 /build 命令手动触发构建（仅协作者/组织成员）
+#   3. 在 PR 中发布构建状态评论，并持续更新（不会重复创建）
+#   4. 支持 Fork PR 的构建（使用 pull_request_target 获取写权限）
+#
+# 安全说明：
+#   - 使用 pull_request_target 事件，在 base 分支上下文运行
+#   - 构建脚本始终从 base 分支 checkout，避免恶意 PR 篡改脚本
+#   - PR 代码单独 checkout 到 workspace 目录
+# =============================================================================
+
+name: PR Build
+
+# =============================================================================
+# 触发条件
+# =============================================================================
+on:
+  # PR 事件：打开、同步（新推送）、重新打开时触发
+  # 注意：使用 pull_request_target 而非 pull_request，以便对 Fork PR 有写权限
+  pull_request_target:
+    types: [opened, synchronize, reopened]
+
+  # Issue 评论事件：用于响应 /build 命令
+  issue_comment:
+    types: [created]
+
+# =============================================================================
+# 权限配置
+# =============================================================================
+permissions:
+  contents: read # 读取仓库内容
+  pull-requests: write # 写入 PR 评论
+  issues: write # 写入 Issue 评论（/build 命令响应）
+  actions: read # 读取 Actions 信息（获取构建日志链接）
+
+# =============================================================================
+# 并发控制
+# =============================================================================
+# 同一 PR 的多次构建会取消之前未完成的构建，避免资源浪费
+# 注意：只有在 should_build=true 时才会进入实际构建流程，
+#       issue_comment 事件如果不是 /build 命令，会在 check-build 阶段快速退出，
+#       不会取消正在进行的构建（因为 cancel-in-progress 只影响同 group 的后续任务）
+concurrency:
+  # 使用不同的 group 策略：
+  # - pull_request_target: 使用 PR 号
+  # - issue_comment: 只有确认是 /build 命令时才使用 PR 号，否则使用 run_id（不冲突）
+  group: pr-build-${{ github.event_name == 'pull_request_target' && github.event.pull_request.number || github.event_name == 'issue_comment' && github.event.issue.pull_request && contains(github.event.comment.body, '/build') && github.event.issue.number || github.run_id }}
+  cancel-in-progress: true
+
+# =============================================================================
+# 任务定义
+# =============================================================================
+jobs:
+  # ---------------------------------------------------------------------------
+  # Job 1: 检查构建条件
+  # ---------------------------------------------------------------------------
+  # 判断是否应该触发构建：
+  #   - pull_request_target 事件：总是触发
+  #   - issue_comment 事件：检查是否为 /build 命令，且用户有权限
+  # ---------------------------------------------------------------------------
+  check-build:
+    runs-on: ubuntu-latest
+    outputs:
+      should_build: ${{ steps.check.outputs.should_build }} # 是否应该构建
+      pr_number: ${{ steps.check.outputs.pr_number }} # PR 编号
+      pr_sha: ${{ steps.check.outputs.pr_sha }} # PR 最新提交 SHA
+      pr_head_repo: ${{ steps.check.outputs.pr_head_repo }} # PR 源仓库（用于 Fork）
+      pr_head_ref: ${{ steps.check.outputs.pr_head_ref }} # PR 源分支
+    steps:
+      # 仅 checkout 脚本目录，加快速度
+      - name: Checkout scripts
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/scripts
+          sparse-checkout-cone-mode: false
+
+      # 使用 Node.js 24 以支持原生 TypeScript 执行
+      - name: Setup Node.js 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+
+      # 执行检查脚本，判断是否触发构建
+      - name: Check trigger condition
+        id: check
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: node --experimental-strip-types .github/scripts/pr-build-check.ts
+
+  # ---------------------------------------------------------------------------
+  # Job 2: 更新评论为"构建中"状态
+  # ---------------------------------------------------------------------------
+  # 在 PR 中创建或更新评论，显示构建正在进行中
+  # ---------------------------------------------------------------------------
+  update-comment-building:
+    needs: check-build
+    if: needs.check-build.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout scripts
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/scripts
+          sparse-checkout-cone-mode: false
+
+      - name: Setup Node.js 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+
+      # 更新 PR 评论，显示构建中状态
+      - name: Update building comment
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ needs.check-build.outputs.pr_number }}
+          PR_SHA: ${{ needs.check-build.outputs.pr_sha }}
+        run: node --experimental-strip-types .github/scripts/pr-build-building.ts
+
+  # ---------------------------------------------------------------------------
+  # Job 3: 构建 Framework 包
+  # ---------------------------------------------------------------------------
+  # 执行 napcat-framework 的构建流程
+  # ---------------------------------------------------------------------------
+  build-framework:
+    needs: [check-build, update-comment-building]
+    if: needs.check-build.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      status: ${{ steps.build.outcome }} # 构建结果：success/failure
+      error: ${{ steps.build.outputs.error }} # 错误信息（如有）
+      version: ${{ steps.version.outputs.version }} # 构建版本号
+    steps:
+      # 【安全】先从 base 分支 checkout 构建脚本
+      # 这样即使 PR 中修改了脚本，也不会被执行
+      - name: Checkout scripts from base
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/scripts
+          sparse-checkout-cone-mode: false
+          path: _scripts
+
+      # 将 PR 代码 checkout 到单独的 workspace 目录
+      - name: Checkout PR code
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ needs.check-build.outputs.pr_head_repo }}
+          ref: ${{ needs.check-build.outputs.pr_sha }}
+          path: workspace
+          fetch-depth: 0  # 需要完整历史来获取 tags
+
+      - name: Setup Node.js 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+
+      # 获取最新 release tag 并生成版本号
+      - name: Generate Version
+        id: version
+        working-directory: workspace
+        run: |
+          # 获取最近的 release tag (格式: vX.X.X)
+          LATEST_TAG=$(git describe --tags --abbrev=0 --match "v[0-9]*.[0-9]*.[0-9]*" 2>/dev/null || echo "v0.0.0")
+          # 去掉 v 前缀
+          BASE_VERSION="${LATEST_TAG#v}"
+          SHORT_SHA="${{ needs.check-build.outputs.pr_sha }}"
+          SHORT_SHA="${SHORT_SHA::7}"
+          VERSION="${BASE_VERSION}-pr.${{ needs.check-build.outputs.pr_number }}.${{ github.run_number }}+${SHORT_SHA}"
+          echo "NAPCAT_VERSION=${VERSION}" >> $GITHUB_ENV
+          echo "Latest tag: ${LATEST_TAG}"
+          echo "Build version: ${VERSION}"
+
+      # 执行构建，使用 base 分支的脚本处理 workspace 中的代码
+      - name: Build
+        id: build
+        working-directory: workspace
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NAPCAT_VERSION: ${{ env.NAPCAT_VERSION }}
+        run: node --experimental-strip-types ../_scripts/.github/scripts/pr-build-run.ts framework
+        continue-on-error: true # 允许失败，后续更新评论时处理
+
+      # 构建成功时上传产物
+      - name: Upload Artifact
+        if: steps.build.outcome == 'success'
+        uses: actions/upload-artifact@v4
+        with:
+          name: NapCat.Framework
+          path: workspace/framework-dist
+          retention-days: 7 # 保留 7 天
+
+  # ---------------------------------------------------------------------------
+  # Job 4: 构建 Shell 包
+  # ---------------------------------------------------------------------------
+  # 执行 napcat-shell 的构建流程（与 Framework 并行执行）
+  # ---------------------------------------------------------------------------
+  build-shell:
+    needs: [check-build, update-comment-building]
+    if: needs.check-build.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+    outputs:
+      status: ${{ steps.build.outcome }} # 构建结果：success/failure
+      error: ${{ steps.build.outputs.error }} # 错误信息（如有）
+      version: ${{ steps.version.outputs.version }} # 构建版本号
+    steps:
+      # 【安全】先从 base 分支 checkout 构建脚本
+      - name: Checkout scripts from base
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/scripts
+          sparse-checkout-cone-mode: false
+          path: _scripts
+
+      # 将 PR 代码 checkout 到单独的 workspace 目录
+      - name: Checkout PR code
+        uses: actions/checkout@v4
+        with:
+          repository: ${{ needs.check-build.outputs.pr_head_repo }}
+          ref: ${{ needs.check-build.outputs.pr_sha }}
+          path: workspace
+          fetch-depth: 0  # 需要完整历史来获取 tags
+
+      - name: Setup Node.js 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+
+      # 获取最新 release tag 并生成版本号
+      - name: Generate Version
+        id: version
+        working-directory: workspace
+        run: |
+          # 获取最近的 release tag (格式: vX.X.X)
+          LATEST_TAG=$(git describe --tags --abbrev=0 --match "v[0-9]*.[0-9]*.[0-9]*" 2>/dev/null || echo "v0.0.0")
+          # 去掉 v 前缀
+          BASE_VERSION="${LATEST_TAG#v}"
+          SHORT_SHA="${{ needs.check-build.outputs.pr_sha }}"
+          SHORT_SHA="${SHORT_SHA::7}"
+          VERSION="${BASE_VERSION}-pr.${{ needs.check-build.outputs.pr_number }}.${{ github.run_number }}+${SHORT_SHA}"
+          echo "NAPCAT_VERSION=${VERSION}" >> $GITHUB_ENV
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+          echo "Latest tag: ${LATEST_TAG}"
+          echo "Build version: ${VERSION}"
+
+      # 执行构建
+      - name: Build
+        id: build
+        working-directory: workspace
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NAPCAT_VERSION: ${{ env.NAPCAT_VERSION }}
+        run: node --experimental-strip-types ../_scripts/.github/scripts/pr-build-run.ts shell
+        continue-on-error: true
+
+      # 构建成功时上传产物
+      - name: Upload Artifact
+        if: steps.build.outcome == 'success'
+        uses: actions/upload-artifact@v4
+        with:
+          name: NapCat.Shell
+          path: workspace/shell-dist
+          retention-days: 7 # 保留 7 天
+
+  # ---------------------------------------------------------------------------
+  # Job 5: 更新评论为构建结果
+  # ---------------------------------------------------------------------------
+  # 汇总所有构建结果，更新 PR 评论显示最终状态
+  # 使用 always() 确保即使构建失败/取消也会执行
+  # ---------------------------------------------------------------------------
+  update-comment-result:
+    needs: [check-build, update-comment-building, build-framework, build-shell]
+    if: always() && needs.check-build.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout scripts
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: .github/scripts
+          sparse-checkout-cone-mode: false
+
+      - name: Setup Node.js 24
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+
+      # 更新评论，显示构建结果和下载链接
+      - name: Update result comment
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ needs.check-build.outputs.pr_number }}
+          PR_SHA: ${{ needs.check-build.outputs.pr_sha }}
+          RUN_ID: ${{ github.run_id }}
+          # 构建版本号
+          NAPCAT_VERSION: ${{ needs.build-framework.outputs.version || needs.build-shell.outputs.version || '' }}
+          # 获取构建状态，如果 job 被跳过则标记为 cancelled
+          FRAMEWORK_STATUS: ${{ needs.build-framework.outputs.status || 'cancelled' }}
+          FRAMEWORK_ERROR: ${{ needs.build-framework.outputs.error }}
+          SHELL_STATUS: ${{ needs.build-shell.outputs.status || 'cancelled' }}
+          SHELL_ERROR: ${{ needs.build-shell.outputs.error }}
+        run: node --experimental-strip-types .github/scripts/pr-build-result.ts

.github/workflows/release.yml

@@ -4,17 +4,48 @@ on:
   workflow_dispatch:
   push:
     tags:
-      - '*'
+      - 'v*'
 
 permissions: write-all
 
 env:
   OPENROUTER_API_URL: https://91vip.futureppo.top/v1/chat/completions
-  OPENROUTER_MODEL: "kimi-k2-0905-turbo"
+  OPENROUTER_MODEL: "copilot/gemini-3-flash-preview"
   RELEASE_NAME: "NapCat"
 
 jobs:
+  # 验证版本号格式
+  validate-version:
+    runs-on: ubuntu-latest
+    outputs:
+      valid: ${{ steps.check.outputs.valid }}
+      version: ${{ steps.check.outputs.version }}
+    steps:
+      - name: Validate semantic version
+        id: check
+        run: |
+          TAG="${GITHUB_REF#refs/tags/}"
+          echo "Checking tag: $TAG"
+          
+          # 语义化版本正则表达式
+          # 支持: v1.0.0, v1.0.0-beta, v1.0.0-rc.1, v1.0.0-alpha.1+build.123
+          SEMVER_REGEX="^v(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(-((0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9][0-9]*|[0-9]*[a-zA-Z-][0-9a-zA-Z-]*))*))?$"
+          
+          if [[ "$TAG" =~ $SEMVER_REGEX ]]; then
+            echo "✅ Valid semantic version: $TAG"
+            echo "valid=true" >> $GITHUB_OUTPUT
+            echo "version=$TAG" >> $GITHUB_OUTPUT
+          else
+            echo "❌ Invalid version format: $TAG"
+            echo "Expected format: vX.Y.Z or vX.Y.Z-prerelease"
+            echo "Examples: v1.0.0, v1.2.3-beta, v2.0.0-rc.1"
+            echo "valid=false" >> $GITHUB_OUTPUT
+            exit 1
+          fi
+
   Build-Framework:
+    needs: validate-version
+    if: needs.validate-version.outputs.valid == 'true'
     runs-on: ubuntu-latest
     steps:
       - name: Clone Main Repository
@@ -24,11 +55,14 @@ jobs:
         with:
           node-version: 20.x
       - name: Build NapCat.Framework
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           npm i -g pnpm
           pnpm i
           pnpm --filter napcat-webui-frontend run build || exit 1
           pnpm run build:framework
+          pnpm --filter napcat-plugin-builtin run build || exit 1
           mv packages/napcat-framework/dist framework-dist
           cd framework-dist
           npm install --omit=dev
@@ -40,6 +74,8 @@ jobs:
           path: framework-dist
 
   Build-Shell:
+    needs: validate-version
+    if: needs.validate-version.outputs.valid == 'true'
     runs-on: ubuntu-latest
     steps:
       - name: Clone Main Repository
@@ -49,11 +85,14 @@ jobs:
         with:
           node-version: 20.x
       - name: Build NapCat.Shell
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
           npm i -g pnpm
           pnpm i
           pnpm --filter napcat-webui-frontend run build || exit 1
           pnpm run build:shell
+          pnpm --filter napcat-plugin-builtin run build || exit 1
           mv packages/napcat-shell/dist shell-dist
           cd shell-dist
           npm install --omit=dev
@@ -161,6 +200,10 @@ jobs:
         with:
           path: ./artifacts
 
+      - name: Download NapCat.Shell.Windows.OneKey.zip
+        run: |
+            curl -L -o NapCat.Shell.Windows.OneKey.zip https://github.com/NapNeko/NapCatResource/raw/main/NapCat.Shell.Windows.OneKey.zip
+
       - name: Zip Artifacts
         run: |
             cd artifacts
@@ -171,10 +214,10 @@ jobs:
 
       - name: Generate release note via OpenRouter
         env:
-          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
           OPENROUTER_API_URL: ${{ env.OPENROUTER_API_URL }}
           OPENROUTER_MODEL: ${{ env.OPENROUTER_MODEL }}
-          GITHUB_OWNER: "NapNeKo"   # 替换成你的 repo owner
+          GITHUB_OWNER: "NapNeko"   # 替换成你的 repo owner
           GITHUB_REPO: "NapCatQQ"   # 替换成你的 repo 名
         run: |
           set -euo pipefail
@@ -199,41 +242,162 @@ jobs:
           done
 
           if [ -z "$PREV_TAG" ]; then
-            echo "❌ Could not find previous tag for $CURRENT_TAG, aborting."
-            exit 1
+            echo "⚠️ Could not find previous tag for $CURRENT_TAG, using first commit"
+            PREV_TAG=$(git rev-list --max-parents=0 HEAD | head -1)
           fi
 
           echo "Previous tag: $PREV_TAG"
 
           # 强制拉取上一个 tag 和当前 tag
-          git fetch origin "refs/tags/$PREV_TAG:refs/tags/$PREV_TAG" --force
-          git fetch origin "refs/tags/$CURRENT_TAG:refs/tags/$CURRENT_TAG" --force
+          git fetch origin "refs/tags/$PREV_TAG:refs/tags/$PREV_TAG" --force || true
+          git fetch origin "refs/tags/$CURRENT_TAG:refs/tags/$CURRENT_TAG" --force || true
 
-          # 获取 commit title + body + 作者，保留换行
-          COMMITS=$(git log --pretty=format:'%h %B (%an)' "$PREV_TAG".."$CURRENT_TAG" | sed 's/$/\\n/')
+          # 获取 commit，使用更清晰的格式
+          # 格式: <type>: <subject> (<hash>)
+          COMMITS=$(git log --pretty=format:'- %s (%h)' "$PREV_TAG".."$CURRENT_TAG" 2>/dev/null || git log --pretty=format:'- %s (%h)' -20)
 
           echo "Commit list from $PREV_TAG to $CURRENT_TAG:"
-          echo -e "$COMMITS"
+          echo "$COMMITS"
+
+          # 获取文件变化统计
+          echo "Getting file change statistics..."
+          FILE_STATS=$(git diff --stat "$PREV_TAG".."$CURRENT_TAG" 2>/dev/null || echo "")
+          
+          # 获取总体统计（最后一行）
+          SUMMARY_LINE=$(echo "$FILE_STATS" | tail -1)
+          echo "Summary: $SUMMARY_LINE"
+          
+          # 获取每个文件的变化（去掉最后一行汇总）
+          # 截断过长的输出（最多50个文件，每行最多80字符）
+          FILE_CHANGES=$(echo "$FILE_STATS" | head -n -1 | head -50 | cut -c1-80)
+          
+          # 如果文件变化太多，进一步精简：只保留主要目录的变化
+          FILE_COUNT=$(echo "$FILE_STATS" | head -n -1 | wc -l)
+          if [ "$FILE_COUNT" -gt 50 ]; then
+            echo "Too many files ($FILE_COUNT), grouping by directory..."
+            # 按目录分组统计
+            DIR_STATS=$(git diff --stat "$PREV_TAG".."$CURRENT_TAG" 2>/dev/null | head -n -1 | \
+              sed 's/|.*//g' | \
+              awk -F'/' '{if(NF>1) print $1"/"$2; else print $1}' | \
+              sort | uniq -c | sort -rn | head -20)
+            FILE_CHANGES="[按目录分组统计 - 共 $FILE_COUNT 个文件变更]
+          $DIR_STATS"
+          fi
+          
+          echo "File changes:"
+          echo "$FILE_CHANGES"
+
+          # 获取具体代码变化（关键文件的diff）
+          echo "Getting code diff for key files..."
+          
+          # 定义关键目录（优先展示这些目录的变化）
+          KEY_DIRS="packages/napcat-core packages/napcat-onebot packages/napcat-webui-backend"
+          
+          # 获取变更的关键文件列表（排除测试、配置等）
+          # 使用 || true 防止 grep 无匹配时返回非零退出码
+          KEY_FILES=$(git diff --name-only "$PREV_TAG".."$CURRENT_TAG" 2>/dev/null | \
+            grep -E "^packages/napcat-(core|onebot|webui-backend|shell)/" || true | \
+            grep -E "\.(ts|js)$" || true | \
+            grep -v -E "(test|spec|\.d\.ts|config)" || true | \
+            head -15) || true
+          
+          CODE_DIFF=""
+          DIFF_CHAR_LIMIT=6000  # 总diff字符限制
+          CURRENT_CHARS=0
+          
+          if [ -n "$KEY_FILES" ]; then
+            for file in $KEY_FILES; do
+              if [ "$CURRENT_CHARS" -ge "$DIFF_CHAR_LIMIT" ]; then
+                CODE_DIFF="$CODE_DIFF
+          [... 更多文件变化已截断 ...]"
+                break
+              fi
+              
+              # 获取单个文件的diff，限制每个文件最多50行
+              FILE_DIFF=$(git diff "$PREV_TAG".."$CURRENT_TAG" -- "$file" 2>/dev/null | head -50) || true
+              FILE_DIFF_LEN=${#FILE_DIFF}
+              
+              # 如果单个文件diff超过1500字符，截断
+              if [ "$FILE_DIFF_LEN" -gt 1500 ]; then
+                FILE_DIFF=$(echo "$FILE_DIFF" | head -c 1500)
+                FILE_DIFF="$FILE_DIFF
+          [... 文件 $file 变化已截断 ...]"
+              fi
+              
+              if [ -n "$FILE_DIFF" ]; then
+                CODE_DIFF="$CODE_DIFF
+          
+          ### $file
+          \`\`\`diff
+          $FILE_DIFF
+          \`\`\`"
+                CURRENT_CHARS=$((CURRENT_CHARS + FILE_DIFF_LEN))
+              fi
+            done
+          fi
+          
+          # 如果没有关键文件变化，获取前5个变更文件的diff
+          if [ -z "$CODE_DIFF" ]; then
+            echo "No key files changed, getting top changed files..."
+            TOP_FILES=$(git diff --name-only "$PREV_TAG".."$CURRENT_TAG" 2>/dev/null | \
+              grep -E "\.(ts|js|yml|md)$" | head -5) || true
+            
+            if [ -n "$TOP_FILES" ]; then
+              for file in $TOP_FILES; do
+                FILE_DIFF=$(git diff "$PREV_TAG".."$CURRENT_TAG" -- "$file" 2>/dev/null | head -30) || true
+                if [ -n "$FILE_DIFF" ] && [ ${#FILE_DIFF} -lt 1000 ]; then
+                  CODE_DIFF="$CODE_DIFF
+          
+          ### $file
+          \`\`\`diff
+          $FILE_DIFF
+          \`\`\`"
+                fi
+              done
+            fi
+          fi
+          
+          # 如果仍然没有代码变化，添加说明
+          if [ -z "$CODE_DIFF" ]; then
+            CODE_DIFF="[本次更新主要涉及配置文件和文档变更，无核心代码变化]"
+          fi
+          
+          echo "Code diff preview:"
+          echo "$CODE_DIFF" | head -50
 
           # 读取 prompt
           PROMPT_FILE=".github/prompt/release_note_prompt.txt"
           SYSTEM_PROMPT=$(<"$PROMPT_FILE")
 
-          # 构建用户内容
-          USER_CONTENT="当前真正的版本: $CURRENT_TAG\n提交列表:\n$COMMITS"
+          # 构建用户内容，传递更多上下文（包含文件变化和代码diff）
+          USER_CONTENT="当前版本: $CURRENT_TAG
+          上一版本: $PREV_TAG
           
-          # 构建请求 JSON
+          ## 提交列表
+          $COMMITS
+          
+          ## 文件变化统计
+          $SUMMARY_LINE
+          
+          ## 变更文件列表
+          $FILE_CHANGES
+          
+          ## 关键代码变化
+          $CODE_DIFF"
+
+          # 构建请求 JSON，增加 max_tokens 以获取更完整的输出
           BODY=$(jq -n \
             --arg system "$SYSTEM_PROMPT" \
             --arg user "$USER_CONTENT" \
-            '{model: env.OPENROUTER_MODEL, messages:[{role:"system", content:$system},{role:"user", content:$user}], temperature:0.3, max_tokens:800}')
+            --arg model "$OPENROUTER_MODEL" \
+            '{model: $model, messages:[{role:"system", content:$system},{role:"user", content:$user}], temperature:0.2, max_tokens:1500}')
 
           echo "=== OpenRouter request body ==="
           echo "$BODY" | jq .
 
           # 调用 OpenRouter
           if RESPONSE=$(curl -s -X POST "$OPENROUTER_API_URL" \
-            -H "Authorization: Bearer $OPENROUTER_API_KEY" \
+            -H "Authorization: Bearer $OPENAI_KEY" \
             -H "Content-Type: application/json" \
             -d "$BODY"); then
             echo "=== raw response ==="
@@ -250,13 +414,18 @@ jobs:
 
             if [ -z "$RELEASE_BODY" ]; then
               echo "❌ OpenRouter failed to generate release note, using default.md"
-              cp .github/prompt/default.md CHANGELOG.md
+              # 替换默认模板中的版本占位符
+              sed "s/{VERSION}/$CURRENT_TAG/g" .github/prompt/default.md > CHANGELOG.md
             else
+              # 后处理：确保版本号正确，并添加比较链接
               echo -e "$RELEASE_BODY" > CHANGELOG.md
+              # 替换可能的占位符
+              sed -i "s/{VERSION}/$CURRENT_TAG/g" CHANGELOG.md
+              sed -i "s/{PREV_VERSION}/$PREV_TAG/g" CHANGELOG.md
             fi
           else
             echo "❌ Curl failed, using default.md"
-            cp .github/prompt/default.md CHANGELOG.md
+            sed "s/{VERSION}/$CURRENT_TAG/g" .github/prompt/default.md > CHANGELOG.md
           fi
           echo "=== generated release note ==="
           cat CHANGELOG.md
@@ -271,4 +440,5 @@ jobs:
             NapCat.Shell.Windows.Node.zip
             NapCat.Framework.zip
             NapCat.Shell.zip
+            NapCat.Shell.Windows.OneKey.zip
           draft: true

README.md

@@ -43,7 +43,7 @@ _Modern protocol-side framework implemented based on NTQQ._
 
 **首次使用**请务必查看如下文档看使用教程
 
-> 项目非盈利，对接问题/基础问题/下层框架问题 请自行搜索解决，本项目社区不提供此类解答。
+> 项目非盈利，涉及 对接问题/基础问题/下层框架问题 请自行搜索解决，本项目社区不提供此类解答。
 
 ## Link
 

package.json

@@ -28,7 +28,6 @@
   },
   "dependencies": {
     "express": "^5.0.0",
-    "silk-wasm": "^3.6.1",
     "ws": "^8.18.3"
   }
 }

packages/napcat-common/package.json

@@ -17,8 +17,7 @@
     },
     "dependencies": {
         "ajv": "^8.13.0",
-        "file-type": "^21.0.0",
-        "silk-wasm": "^3.6.1"
+        "file-type": "^21.0.0"
     },
     "devDependencies": {
         "@types/node": "^22.0.1"

packages/napcat-common/src/audio-worker.ts

@@ -1,20 +0,0 @@
-import { encode } from 'silk-wasm';
-import { parentPort } from 'worker_threads';
-
-export interface EncodeArgs {
-  input: ArrayBufferView | ArrayBuffer
-  sampleRate: number
-}
-export function recvTask<T> (cb: (taskData: T) => Promise<unknown>) {
-  parentPort?.on('message', async (taskData: T) => {
-    try {
-      const ret = await cb(taskData);
-      parentPort?.postMessage(ret);
-    } catch (error: unknown) {
-      parentPort?.postMessage({ error: (error as Error).message });
-    }
-  });
-}
-recvTask<EncodeArgs>(async ({ input, sampleRate }) => {
-  return await encode(input, sampleRate);
-});

packages/napcat-common/src/helper.ts

@@ -2,6 +2,11 @@ import path from 'node:path';
 import fs from 'fs';
 import os from 'node:os';
 import { QQVersionConfigType, QQLevel } from './types';
+import { compareSemVer } from './version';
+import { getAllGitHubTags as getAllTagsFromMirror } from './mirror';
+
+// 导出 compareSemVer 供其他模块使用
+export { compareSemVer } from './version';
 
 export async function solveProblem<T extends (...arg: any[]) => any> (func: T, ...args: Parameters<T>): Promise<ReturnType<T> | undefined> {
   return new Promise<ReturnType<T> | undefined>((resolve) => {
@@ -211,3 +216,25 @@ export function parseAppidFromMajor (nodeMajor: string): string | undefined {
 
   return undefined;
 }
+
+// ============== GitHub Tags 获取 ==============
+// 使用 mirror 模块统一管理镜像
+
+export async function getAllTags (): Promise<{ tags: string[], mirror: string; }> {
+  return getAllTagsFromMirror('NapNeko', 'NapCatQQ');
+}
+
+
+export async function getLatestTag (): Promise<string> {
+  const { tags } = await getAllTags();
+
+  // 使用 SemVer 规范排序
+  tags.sort((a, b) => compareSemVer(a, b));
+
+  const latest = tags.at(-1);
+  if (!latest) {
+    throw new Error('No tags found');
+  }
+  // 去掉开头的 v
+  return latest.replace(/^v/, '');
+}

packages/napcat-common/src/request.ts

@@ -3,11 +3,11 @@ import http from 'node:http';
 
 export class RequestUtil {
   // 适用于获取服务器下发cookies时获取，仅GET
-  static async HttpsGetCookies (url: string): Promise<{ [key: string]: string }> {
+  static async HttpsGetCookies (url: string): Promise<{ [key: string]: string; }> {
     const client = url.startsWith('https') ? https : http;
     return new Promise((resolve, reject) => {
       const req = client.get(url, (res) => {
-        const cookies: { [key: string]: string } = {};
+        const cookies: { [key: string]: string; } = {};
 
         res.on('data', () => { }); // Necessary to consume the stream
         res.on('end', () => {
@@ -27,7 +27,7 @@ export class RequestUtil {
     });
   }
 
-  private static async handleRedirect (res: http.IncomingMessage, url: string, cookies: { [key: string]: string }): Promise<{ [key: string]: string }> {
+  private static async handleRedirect (res: http.IncomingMessage, url: string, cookies: { [key: string]: string; }): Promise<{ [key: string]: string; }> {
     if (res.statusCode === 301 || res.statusCode === 302) {
       if (res.headers.location) {
         const redirectUrl = new URL(res.headers.location, url);
@@ -39,7 +39,7 @@ export class RequestUtil {
     return cookies;
   }
 
-  private static extractCookies (setCookieHeaders: string[], cookies: { [key: string]: string }) {
+  private static extractCookies (setCookieHeaders: string[], cookies: { [key: string]: string; }) {
     setCookieHeaders.forEach((cookie) => {
       const parts = cookie.split(';')[0]?.split('=');
       if (parts) {
@@ -53,9 +53,10 @@ export class RequestUtil {
   }
 
   // 请求和回复都是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> {
+  // 支持 301/302 重定向（最多 5 次）
+  static async HttpGetJson<T> (url: string, method: string = 'GET', data?: any, headers: {
+    [key: string]: string;
+  } = {}, isJsonRet: boolean = true, isArgJson: boolean = true, maxRedirects: number = 5): Promise<T> {
     const option = new URL(url);
     const protocol = url.startsWith('https://') ? https : http;
     const options = {
@@ -71,6 +72,20 @@ export class RequestUtil {
     //     },
     return new Promise((resolve, reject) => {
       const req = protocol.request(options, (res: http.IncomingMessage) => {
+        // 处理重定向
+        if ((res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307 || res.statusCode === 308) && res.headers.location) {
+          if (maxRedirects <= 0) {
+            reject(new Error('Too many redirects'));
+            return;
+          }
+          const redirectUrl = new URL(res.headers.location, url).href;
+          // 递归跟随重定向
+          this.HttpGetJson<T>(redirectUrl, method, data, headers, isJsonRet, isArgJson, maxRedirects - 1)
+            .then(resolve)
+            .catch(reject);
+          return;
+        }
+
         let responseBody = '';
         res.on('data', (chunk: string | Buffer) => {
           responseBody += chunk.toString();
@@ -109,7 +124,7 @@ export class RequestUtil {
   }
 
   // 请求返回都是原始内容
-  static async HttpGetText (url: string, method: string = 'GET', data?: any, headers: { [key: string]: string } = {}) {
+  static async HttpGetText (url: string, method: string = 'GET', data?: any, headers: { [key: string]: string; } = {}) {
     return this.HttpGetJson<string>(url, method, data, headers, false, false);
   }
 }

packages/napcat-common/src/version.ts

@@ -1,2 +1,118 @@
 // @ts-ignore
-export const napCatVersion = (typeof import.meta?.env !== 'undefined' && import.meta.env.VITE_NAPCAT_VERSION) || 'alpha';
+export const napCatVersion = (typeof import.meta?.env !== 'undefined' && import.meta.env.VITE_NAPCAT_VERSION) || '1.0.0-dev';
+
+/**
+ * SemVer 2.0 正则表达式
+ * 格式: 主版本号.次版本号.修订号[-先行版本号][+版本编译信息]
+ * 参考: https://semver.org/lang/zh-CN/
+ */
+const SEMVER_REGEX = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+export interface SemVerInfo {
+  valid: boolean;
+  normalized: string;
+  major: number;
+  minor: number;
+  patch: number;
+  prerelease: string | null;
+  buildmetadata: string | null;
+}
+
+/**
+ * 解析并验证版本号是否符合 SemVer 2.0 规范
+ * @param version - 版本字符串 (支持 v 前缀)
+ * @returns SemVer 解析结果
+ */
+export function parseSemVer (version: string | undefined | null): SemVerInfo {
+  if (!version || typeof version !== 'string') {
+    return { valid: false, normalized: '1.0.0-dev', major: 1, minor: 0, patch: 0, prerelease: 'dev', buildmetadata: null };
+  }
+
+  const match = version.trim().match(SEMVER_REGEX);
+  if (match) {
+    const major = parseInt(match[1]!, 10);
+    const minor = parseInt(match[2]!, 10);
+    const patch = parseInt(match[3]!, 10);
+    const prerelease = match[4] || null;
+    const buildmetadata = match[5] || null;
+
+    // 构建标准化版本号（不带 v 前缀）
+    let normalized = `${major}.${minor}.${patch}`;
+    if (prerelease) normalized += `-${prerelease}`;
+    if (buildmetadata) normalized += `+${buildmetadata}`;
+
+    return { valid: true, normalized, major, minor, patch, prerelease, buildmetadata };
+  }
+  return { valid: false, normalized: '1.0.0-dev', major: 1, minor: 0, patch: 0, prerelease: 'dev', buildmetadata: null };
+}
+
+/**
+ * 验证版本号是否符合 SemVer 2.0 规范
+ * @param version - 版本字符串
+ * @returns 是否有效
+ */
+export function isValidSemVer (version: string | undefined | null): boolean {
+  return parseSemVer(version).valid;
+}
+
+/**
+ * 比较两个 SemVer 版本号
+ * @param v1 - 版本号1
+ * @param v2 - 版本号2
+ * @returns -1 (v1 < v2), 0 (v1 == v2), 1 (v1 > v2)
+ */
+export function compareSemVer (v1: string, v2: string): -1 | 0 | 1 {
+  const a = parseSemVer(v1);
+  const b = parseSemVer(v2);
+
+  if (!a.valid || !b.valid) {
+    return 0;
+  }
+
+  // 比较主版本号
+  if (a.major !== b.major) return a.major > b.major ? 1 : -1;
+  // 比较次版本号
+  if (a.minor !== b.minor) return a.minor > b.minor ? 1 : -1;
+  // 比较修订号
+  if (a.patch !== b.patch) return a.patch > b.patch ? 1 : -1;
+
+  // 有先行版本号的版本优先级较低
+  if (a.prerelease && !b.prerelease) return -1;
+  if (!a.prerelease && b.prerelease) return 1;
+
+  // 两者都有先行版本号时，按字典序比较
+  if (a.prerelease && b.prerelease) {
+    const aParts = a.prerelease.split('.');
+    const bParts = b.prerelease.split('.');
+    const len = Math.max(aParts.length, bParts.length);
+
+    for (let i = 0; i < len; i++) {
+      const aPart = aParts[i];
+      const bPart = bParts[i];
+
+      if (aPart === undefined) return -1;
+      if (bPart === undefined) return 1;
+
+      const aNum = /^\d+$/.test(aPart) ? parseInt(aPart, 10) : NaN;
+      const bNum = /^\d+$/.test(bPart) ? parseInt(bPart, 10) : NaN;
+
+      // 数字 vs 数字
+      if (!isNaN(aNum) && !isNaN(bNum)) {
+        if (aNum !== bNum) return aNum > bNum ? 1 : -1;
+        continue;
+      }
+      // 数字优先级低于字符串
+      if (!isNaN(aNum)) return -1;
+      if (!isNaN(bNum)) return 1;
+      // 字符串 vs 字符串
+      if (aPart !== bPart) return aPart > bPart ? 1 : -1;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * 获取解析后的当前版本信息
+ */
+export const napCatVersionInfo = parseSemVer(napCatVersion);

packages/napcat-core/adapters/NodeIDependsAdapter.ts

@@ -5,7 +5,7 @@ export class NodeIDependsAdapter {
 
   }
 
-  onMSFSsoError (_args: unknown) {
+  onMSFSsoError (_code: number, _desc: string) {
 
   }
 

packages/napcat-core/apis/file.ts

@@ -33,7 +33,7 @@ export class NTQQFileApi {
       'http://ss.xingzhige.com/music_card/rkey',
       'https://secret-service.bietiaop.com/rkeys',
     ],
-    this.context.logger
+      this.context.logger
     );
   }
 
@@ -138,7 +138,7 @@ export class NTQQFileApi {
     })).urlResult.domainUrl;
   }
 
-  async uploadFile (filePath: string, elementType: ElementType = ElementType.PIC, elementSubType: number = 0) {
+  async uploadFile (filePath: string, elementType: ElementType = ElementType.PIC, elementSubType: number = 0, uploadGroupFile = true) {
     const fileMd5 = await calculateFileMD5(filePath);
     const extOrEmpty = await fileTypeFromFile(filePath).then(e => e?.ext ?? '').catch(() => '');
     const ext = extOrEmpty ? `.${extOrEmpty}` : '';
@@ -146,24 +146,33 @@ export class NTQQFileApi {
     if (fileName.indexOf('.') === -1) {
       fileName += ext;
     }
-
-    const mediaPath = this.context.session.getMsgService().getRichMediaFilePathForGuild({
-      md5HexStr: fileMd5,
-      fileName,
-      elementType,
-      elementSubType,
-      thumbSize: 0,
-      needCreate: true,
-      downloadType: 1,
-      file_uuid: '',
-    });
-
-    await this.copyFile(filePath, mediaPath);
     const fileSize = await this.getFileSize(filePath);
+    if (uploadGroupFile) {
+      const mediaPath = this.context.session.getMsgService().getRichMediaFilePathForGuild({
+        md5HexStr: fileMd5,
+        fileName,
+        elementType,
+        elementSubType,
+        thumbSize: 0,
+        needCreate: true,
+        downloadType: 1,
+        file_uuid: '',
+      });
+
+      await this.copyFile(filePath, mediaPath);
+
+      return {
+        md5: fileMd5,
+        fileName,
+        path: mediaPath,
+        fileSize,
+        ext,
+      };
+    }
     return {
       md5: fileMd5,
       fileName,
-      path: mediaPath,
+      path: filePath,
       fileSize,
       ext,
     };

packages/napcat-core/external/appid.json

@@ -466,5 +466,57 @@
   "6.9.85-42086": {
     "appid": 537320237,
     "qua": "V1_MAC_NQ_6.9.85_42086_GW_B"
+  },
+  "9.9.23-42430": {
+    "appid": 537320212,
+    "qua": "V1_WIN_NQ_9.9.23_42430_GW_B"
+  },
+  "9.9.25-42744": {
+    "appid": 537328470,
+    "qua": "V1_WIN_NQ_9.9.23_42744_GW_B"
+  },
+  "6.9.86-42744": {
+    "appid": 537328495,
+    "qua": "V1_MAC_NQ_6.9.85_42744_GW_B"
+  },
+  "9.9.25-42905": {
+    "appid": 537328521,
+    "qua": "V1_WIN_NQ_9.9.25_42905_GW_B"
+  },
+  "6.9.86-42905": {
+    "appid": 537328546,
+    "qua": "V1_MAC_NQ_6.9.86_42905_GW_B"
+  },
+  "3.2.22-42941": {
+    "appid": 537328659,
+    "qua": "V1_LNX_NQ_3.2.22_42941_GW_B"
+  },
+  "9.9.25-42941": {
+    "appid": 537328623,
+    "qua": "V1_WIN_NQ_9.9.25_42941_GW_B"
+  },
+  "6.9.86-42941": {
+    "appid": 537328648,
+    "qua": "V1_MAC_NQ_6.9.86_42941_GW_B"
+  },
+  "9.9.26-44175": {
+    "appid": 537336450,
+    "qua": "V1_WIN_NQ_9.9.26_44175_GW_B"
+  },
+  "9.9.26-44343": {
+    "appid": 537336603,
+    "qua": "V1_WIN_NQ_9.9.26_44343_GW_B"
+  },
+  "3.2.23-44343": {
+    "appid": 537336639,
+    "qua": "V1_LNX_NQ_3.2.23_44343_GW_B"
+  },
+  "9.9.26-44498": {
+    "appid": 537337416,
+    "qua": "V1_WIN_NQ_9.9.26_44498_GW_B"
+  },
+  "9.9.26-44725": {
+    "appid": 537337569,
+    "qua": "V1_WIN_NQ_9.9.26_44725_GW_B"
   }
 }

packages/napcat-core/external/napi2native.json

@@ -87,8 +87,72 @@
     "send": "23B0330",
     "recv": "0957648"
   },
+  "3.2.21-42086-arm64": {
+    "send": "3D6D98C",
+    "recv": "14797C8"
+  },
   "3.2.21-42086-x64": {
     "send": "5B42CF0",
     "recv": "2FDA6F0"
+  },
+  "9.9.23-42430-x64": {
+    "send": "0A01A34",
+    "recv": "1D1CFF9"
+  },
+  "9.9.25-42744-x64": {
+    "send": "0A0D104",
+    "recv": "1D3E7F9"
+  },
+  "6.9.85-42744-arm64": {
+    "send": "23DFEF0",
+    "recv": "095FD80"
+  },
+  "9.9.25-42905-x64": {
+    "send": "0A12E74",
+    "recv": "1D450FD"
+  },
+  "6.9.86-42905-arm64": {
+    "send": "2342408",
+    "recv": "09639B8"
+  },
+  "3.2.22-42941-x64": {
+    "send": "5BC1630",
+    "recv": "3011E00"
+  },
+  "3.2.22-42941-arm64": {
+    "send": "3DC90AC",
+    "recv": "1497A70"
+  },
+  "9.9.25-42941-x64": {
+    "send": "0A131D4",
+    "recv": "1D4547D"
+  },
+  "6.9.86-42941-arm64": {
+    "send": "2346108",
+    "recv": "09675F0"
+  },
+  "9.9.26-44175-x64": {
+    "send": "0A0F2EC",
+    "recv": "1D3AD4D"
+  },
+  "9.9.26-44343-x64": {
+    "send": "0A0F7BC",
+    "recv": "1D3C3CD"
+  },
+  "3.2.23-44343-arm64": {
+    "send": "3C867DC",
+    "recv": "1404938"
+  },
+  "3.2.23-44343-x64": {
+    "send": "59A27B0",
+    "recv": "2FFBE90"
+  },
+  "9.9.26-44498-x64": {
+    "send": "0A1051C",
+    "recv": "1D3BC0D"
+  },
+  "9.9.26-44725-x64": {
+    "send": "0A18D0C",
+    "recv": "1D4BF0D"
   }
 }

packages/napcat-core/external/packet.json

@@ -602,5 +602,65 @@
   "3.2.21-42086-arm64": {
     "send": "6B13038",
     "recv": "6B169C8"
+  },
+  "9.9.23-42430-x64": {
+    "send": "2C9A4A0",
+    "recv": "2C9DA20"
+  },
+  "9.9.25-42744-x64": {
+    "send": "2CD8E40",
+    "recv": "2CDC3C0"
+  },
+  "6.9.86-42744-arm64": {
+    "send": "3DCC840",
+    "recv": "3DCF150"
+  },
+  "9.9.25-42905-x64": {
+    "send": "2CE46A0",
+    "recv": "2CE7C20"
+  },
+  "6.9.86-42905-arm64": {
+    "send": "3DD6098",
+    "recv": "3DD89A8"
+  },
+  "3.2.22-42941-x64": {
+    "send": "A8AD8A0",
+    "recv": "A8B1320"
+  },
+  "9.9.25-42941-x64": {
+    "send": "2CE4DA0",
+    "recv": "2CE8320"
+  },
+  "3.2.22-42941-arm64": {
+    "send": "6BC95E8",
+    "recv": "6BCCF78"
+  },
+  "6.9.86-42941-arm64": {
+    "send": "3DDDAD0",
+    "recv": "3DE03E0"
+  },
+  "9.9.26-44175-x64": {
+    "send": "2CD84A0",
+    "recv": "2CDBA20"
+  },
+  "3.2.23-44343-x64": {
+    "send": "A46F140",
+    "recv": "A472BE0"
+  },
+  "9.9.26-44343-x64": {
+    "send": "2CD8EE0",
+    "recv": "2CDC460"
+  },
+  "3.2.23-44343-arm64": {
+    "send": "6926F60",
+    "recv": "692A910"
+  },
+  "9.9.26-44498-x64": {
+    "send": "2CDAE40",
+    "recv": "2CDE3C0"
+  },
+  "9.9.26-44725-x64": {
+    "send": "2CEBB20",
+    "recv": "2CEF0A0"
   }
 }

packages/napcat-core/helper/audio.ts

@@ -1,19 +1,8 @@
 import fsPromise from 'fs/promises';
 import path from 'node:path';
 import { randomUUID } from 'crypto';
-import { EncodeResult, getDuration, getWavFileInfo, isSilk, isWav } from 'silk-wasm';
 import { LogWrapper } from '@/napcat-core/helper/log';
-import { EncodeArgs } from 'napcat-common/src/audio-worker';
 import { FFmpegService } from '@/napcat-core/helper/ffmpeg/ffmpeg';
-import { runTask } from 'napcat-common/src/worker';
-import { fileURLToPath } from 'node:url';
-
-const ALLOW_SAMPLE_RATE = [8000, 12000, 16000, 24000, 32000, 44100, 48000];
-
-function getWorkerPath () {
-  // return new URL(/* @vite-ignore */ './audio-worker.mjs', import.meta.url).href;
-  return path.join(path.dirname(fileURLToPath(import.meta.url)), 'audio-worker.mjs');
-}
 
 async function guessDuration (pttPath: string, logger: LogWrapper) {
   const pttFileInfo = await fsPromise.stat(pttPath);
@@ -22,51 +11,23 @@ async function guessDuration (pttPath: string, logger: LogWrapper) {
   return duration;
 }
 
-async function handleWavFile (
-  file: Buffer,
-  filePath: string,
-  pcmPath: string
-): Promise<{ input: Buffer; sampleRate: number }> {
-  const { fmt } = getWavFileInfo(file);
-  if (!ALLOW_SAMPLE_RATE.includes(fmt.sampleRate)) {
-    const result = await FFmpegService.convert(filePath, pcmPath);
-    return { input: await fsPromise.readFile(pcmPath), sampleRate: result.sampleRate };
-  }
-  return { input: file, sampleRate: fmt.sampleRate };
-}
-
 export async function encodeSilk (filePath: string, TEMP_DIR: string, logger: LogWrapper) {
   try {
-    const file = await fsPromise.readFile(filePath);
     const pttPath = path.join(TEMP_DIR, randomUUID());
-    if (!isSilk(file)) {
+    if (!(await FFmpegService.isSilk(filePath))) {
       logger.log(`语音文件${filePath}需要转换成silk`);
-      const pcmPath = `${pttPath}.pcm`;
-      // const { input, sampleRate } = isWav(file) ? await handleWavFile(file, filePath, pcmPath): { input: await FFmpegService.convert(filePath, pcmPath) ? await fsPromise.readFile(pcmPath) : Buffer.alloc(0), sampleRate: 24000 };
-      let input: Buffer;
-      let sampleRate: number;
-      if (isWav(file)) {
-        const result = await handleWavFile(file, filePath, pcmPath);
-        input = result.input;
-        sampleRate = result.sampleRate;
-      } else {
-        const result = await FFmpegService.convert(filePath, pcmPath);
-        input = await fsPromise.readFile(pcmPath);
-        sampleRate = result.sampleRate;
-      }
-      const silk = await runTask<EncodeArgs, EncodeResult>(getWorkerPath(), { input, sampleRate });
-      fsPromise.unlink(pcmPath).catch((e) => logger.logError('删除临时文件失败', pcmPath, e));
-      await fsPromise.writeFile(pttPath, Buffer.from(silk.data));
-      logger.log(`语音文件${filePath}转换成功!`, pttPath, '时长:', silk.duration);
+      await FFmpegService.convertToNTSilkTct(filePath, pttPath);
+      const duration = await FFmpegService.getDuration(filePath);
+      logger.log(`语音文件${filePath}转换成功!`, pttPath, '时长:', duration);
       return {
         converted: true,
         path: pttPath,
-        duration: silk.duration / 1000,
+        duration: duration,
       };
     } else {
       let duration = 0;
       try {
-        duration = getDuration(file) / 1000;
+        duration = await FFmpegService.getDuration(filePath);
       } catch (e: unknown) {
         logger.log('获取语音文件时长失败, 使用文件大小推测时长', filePath, (e as Error).stack);
         duration = await guessDuration(filePath, logger);

packages/napcat-core/helper/ffmpeg/ffmpeg-adapter-interface.ts

@@ -27,21 +27,27 @@ export interface IFFmpegAdapter {
   readonly name: string;
 
   /** 是否可用 */
-  isAvailable(): Promise<boolean>;
+  isAvailable (): Promise<boolean>;
 
   /**
      * 获取视频信息(包含缩略图)
      * @param videoPath 视频文件路径
      * @returns 视频信息
      */
-  getVideoInfo(videoPath: string): Promise<VideoInfoResult>;
+  getVideoInfo (videoPath: string): Promise<VideoInfoResult>;
 
   /**
      * 获取音视频文件时长
      * @param filePath 文件路径
      * @returns 时长(秒)
      */
-  getDuration(filePath: string): Promise<number>;
+  getDuration (filePath: string): Promise<number>;
+
+  /**
+   * 判断是否为 Silk 格式
+   * @param filePath 文件路径
+   */
+  isSilk (filePath: string): Promise<boolean>;
 
   /**
      * 转换音频为 PCM 格式
@@ -49,7 +55,7 @@ export interface IFFmpegAdapter {
      * @param pcmPath 输出 PCM 文件路径
      * @returns PCM 数据 Buffer
      */
-  convertToPCM(filePath: string, pcmPath: string): Promise<{ result: boolean, sampleRate: number }>;
+  convertToPCM (filePath: string, pcmPath: string): Promise<{ result: boolean, sampleRate: number; }>;
 
   /**
      * 转换音频文件
@@ -57,12 +63,14 @@ export interface IFFmpegAdapter {
      * @param outputFile 输出文件路径
      * @param format 目标格式 ('amr' | 'silk' 等)
      */
-  convertFile(inputFile: string, outputFile: string, format: string): Promise<void>;
+  convertFile (inputFile: string, outputFile: string, format: string): Promise<void>;
 
   /**
      * 提取视频缩略图
      * @param videoPath 视频文件路径
      * @param thumbnailPath 缩略图输出路径
      */
-  extractThumbnail(videoPath: string, thumbnailPath: string): Promise<void>;
+  extractThumbnail (videoPath: string, thumbnailPath: string): Promise<void>;
+
+  convertToNTSilkTct (inputFile: string, outputFile: string): Promise<void>;
 }

packages/napcat-core/helper/ffmpeg/ffmpeg-addon-adapter.ts

@@ -5,7 +5,7 @@
 
 import { platform, arch } from 'node:os';
 import path from 'node:path';
-import { existsSync } from 'node:fs';
+import { existsSync, openSync, readSync, closeSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import type { FFmpeg } from './ffmpeg-addon';
 import type { IFFmpegAdapter, VideoInfoResult } from './ffmpeg-adapter-interface';
@@ -87,6 +87,22 @@ export class FFmpegAddonAdapter implements IFFmpegAdapter {
     return addon.getDuration(filePath);
   }
 
+  /**
+   * 判断是否为 Silk 格式
+   */
+  async isSilk (filePath: string): Promise<boolean> {
+    try {
+      const fd = openSync(filePath, 'r');
+      const buffer = Buffer.alloc(10);
+      readSync(fd, buffer, 0, 10, 0);
+      closeSync(fd);
+      const header = buffer.toString();
+      return header.includes('#!SILK') || header.includes('\x02#!SILK');
+    } catch {
+      return false;
+    }
+  }
+
   /**
      * 转换为 PCM
      */
@@ -106,6 +122,11 @@ export class FFmpegAddonAdapter implements IFFmpegAdapter {
     await addon.decodeAudioToFmt(inputFile, outputFile, format);
   }
 
+  async convertToNTSilkTct (inputFile: string, outputFile: string): Promise<void> {
+    const addon = this.ensureAddon();
+    await addon.convertToNTSilkTct(inputFile, outputFile);
+  }
+
   /**
      * 提取缩略图
      */

packages/napcat-core/helper/ffmpeg/ffmpeg-addon.ts

@@ -70,4 +70,6 @@ export interface FFmpeg {
      */
   decodeAudioToPCM (filePath: string, pcmPath: string, sampleRate?: number): Promise<{ result: boolean, sampleRate: number; }>;
   decodeAudioToFmt (filePath: string, pcmPath: string, format: string): Promise<{ channels: number; sampleRate: number; format: string; }>;
+
+  convertToNTSilkTct (inputFile: string, outputFile: string): Promise<void>;
 }

packages/napcat-core/helper/ffmpeg/ffmpeg-exec-adapter.ts

@@ -3,7 +3,7 @@
  * 使用 execFile 调用 FFmpeg 命令行工具的适配器实现
  */
 
-import { readFileSync, existsSync, mkdirSync } from 'fs';
+import { readFileSync, existsSync, mkdirSync, openSync, readSync, closeSync } from 'fs';
 import { dirname, join } from 'path';
 import { execFile } from 'child_process';
 import { promisify } from 'util';
@@ -154,6 +154,22 @@ export class FFmpegExecAdapter implements IFFmpegAdapter {
     }
   }
 
+  /**
+   * 判断是否为 Silk 格式
+   */
+  async isSilk (filePath: string): Promise<boolean> {
+    try {
+      const fd = openSync(filePath, 'r');
+      const buffer = Buffer.alloc(10);
+      readSync(fd, buffer, 0, 10, 0);
+      closeSync(fd);
+      const header = buffer.toString();
+      return header.includes('#!SILK') || header.includes('\x02#!SILK');
+    } catch {
+      return false;
+    }
+  }
+
   /**
      * 转换为 PCM
      */
@@ -241,4 +257,8 @@ export class FFmpegExecAdapter implements IFFmpegAdapter {
       throw new Error(`提取缩略图失败: ${(error as Error).message}`);
     }
   }
+
+  async convertToNTSilkTct (_inputFile: string, _outputFile: string): Promise<void> {
+    throw new Error('convertToNTSilkTct is not implemented in FFmpegExecAdapter');
+  }
 }

packages/napcat-core/helper/ffmpeg/ffmpeg.ts

@@ -64,7 +64,10 @@ export class FFmpegService {
     }
     return this.adapter;
   }
-
+  public static async convertToNTSilkTct (inputFile: string, outputFile: string): Promise<void> {
+    const adapter = await this.getAdapter();
+    await adapter.convertToNTSilkTct(inputFile, outputFile);
+  }
   /**
      * 设置 FFmpeg 路径并更新适配器
      * @deprecated 建议使用 init() 方法初始化
@@ -92,11 +95,27 @@ export class FFmpegService {
   /**
      * 转换音频文件
      */
-  public static async convertFile (inputFile: string, outputFile: string, format: string): Promise<void> {
+  public static async convertAudioFmt (inputFile: string, outputFile: string, format: string): Promise<void> {
     const adapter = await this.getAdapter();
     await adapter.convertFile(inputFile, outputFile, format);
   }
 
+  /**
+   * 获取音频时长
+   */
+  public static async getDuration (filePath: string): Promise<number> {
+    const adapter = await this.getAdapter();
+    return adapter.getDuration(filePath);
+  }
+
+  /**
+   * 判断是否为 Silk 格式
+   */
+  public static async isSilk (filePath: string): Promise<boolean> {
+    const adapter = await this.getAdapter();
+    return adapter.isSilk(filePath);
+  }
+
   /**
      * 转换为 PCM 格式
      */

packages/napcat-core/index.ts

@@ -17,7 +17,6 @@ import {
   WrapperSessionInitConfig,
 } from '@/napcat-core/wrapper';
 import { LogLevel, LogWrapper } from '@/napcat-core/helper/log';
-import { NodeIKernelLoginService } from '@/napcat-core/services';
 import { QQBasicInfoWrapper } from '@/napcat-core/helper/qq-basic-info';
 import { NapCatPathWrapper } from 'napcat-common/src/path';
 import path from 'node:path';
@@ -126,7 +125,7 @@ export class NapCatCore {
     container.bind(TypedEventEmitter).toConstantValue(this.event);
     ReceiverServiceRegistry.forEach((ServiceClass, serviceName) => {
       container.bind(ServiceClass).toSelf();
-      console.log(`Registering service handler for: ${serviceName}`);
+      // console.log(`Registering service handler for: ${serviceName}`);
       this.context.packetHandler.onCmd(serviceName, ({ seq, hex_data }) => {
         const serviceInstance = container.get(ServiceClass);
         return serviceInstance.handler(seq, hex_data);
@@ -178,8 +177,10 @@ export class NapCatCore {
 
     msgListener.onKickedOffLine = (Info: KickedOffLineInfo) => {
       // 下线通知
-      this.context.logger.logError('[KickedOffLine] [' + Info.tipsTitle + '] ' + Info.tipsDesc);
+      const tips = `[KickedOffLine] [${Info.tipsTitle}] ${Info.tipsDesc}`;
+      this.context.logger.logError(tips);
       this.selfInfo.online = false;
+      this.event.emit('KickedOffLine', tips);
     };
     msgListener.onRecvMsg = (msgs) => {
       msgs.forEach(msg => this.context.logger.logMessage(msg, this.selfInfo));
@@ -278,7 +279,6 @@ export interface InstanceContext {
   readonly wrapper: WrapperNodeApi;
   readonly session: NodeIQQNTWrapperSession;
   readonly logger: LogWrapper;
-  readonly loginService: NodeIKernelLoginService;
   readonly basicInfoWrapper: QQBasicInfoWrapper;
   readonly pathWrapper: NapCatPathWrapper;
   readonly packetHandler: NativePacketHandler;

packages/napcat-core/listeners/NodeIKernelLoginListener.ts

@@ -53,6 +53,8 @@ export class NodeIKernelLoginListener {
 
   onLoginState (..._args: any[]): any {
   }
+  onLoginRecordUpdate (..._args: any[]): any {
+  }
 }
 
 export interface QRCodeLoginSucceedResult {

packages/napcat-core/listeners/NodeIKernelStorageCleanListener.ts

@@ -3,7 +3,7 @@ export class NodeIKernelStorageCleanListener {
 
   }
 
-  onScanCacheProgressChanged (_args: unknown): any {
+  onScanCacheProgressChanged (_current_progress: number, _total_progress: number): any {
 
   }
 
@@ -11,7 +11,7 @@ export class NodeIKernelStorageCleanListener {
 
   }
 
-  onFinishScan (_args: unknown): any {
+  onFinishScan (_sizes: Array<`${number}`>): any {
 
   }
 

packages/napcat-core/packet/handler/eventList.ts

@@ -1,6 +1,7 @@
 import { TypedEventEmitter } from './typeEvent';
 
 export interface AppEvents {
-  'event:emoji_like': { groupId: string; senderUin: string; emojiId: string, msgSeq: string, isAdd: boolean, count: number };
+  'event:emoji_like': { groupId: string; senderUin: string; emojiId: string, msgSeq: string, isAdd: boolean, count: number; };
+  KickedOffLine: string;
 }
 export const appEvent = new TypedEventEmitter<AppEvents>();

packages/napcat-core/packet/highway/highwayContext.ts

@@ -15,8 +15,12 @@ import { NapProtoMsg } from 'napcat-protobuf';
 import * as proto from '@/napcat-core/packet/transformer/proto';
 import * as trans from '@/napcat-core/packet/transformer';
 import fs from 'fs';
+import path from 'path';
 import { NapCoreContext } from '@/napcat-core/packet/context/napCoreContext';
 import { PacketClientContext } from '@/napcat-core/packet/context/clientContext';
+import { FFmpegService } from '@/napcat-core/helper/ffmpeg/ffmpeg';
+import { defaultVideoThumbB64 } from '@/napcat-core/helper/ffmpeg/video';
+import { calculateFileMD5 } from 'napcat-common/src/file';
 
 export const BlockSize = 1024 * 1024;
 
@@ -105,13 +109,89 @@ export class PacketHighwayContext {
     if (+(video.fileSize ?? 0) > 1024 * 1024 * 100) {
       throw new Error(`[Highway] 视频文件过大: ${(+(video.fileSize ?? 0) / (1024 * 1024)).toFixed(2)} MB > 100 MB，请使用文件上传！`);
     }
-    if (peer.chatType === ChatType.KCHATTYPEGROUP) {
-      await this.uploadGroupVideo(+peer.peerUid, video);
-    } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
-      await this.uploadC2CVideo(peer.peerUid, video);
-    } else {
-      throw new Error(`[Highway] unsupported chatType: ${peer.chatType}`);
+
+    // 如果缺少视频缩略图，自动生成一个
+    let tempThumbPath: string | null = null;
+    let thumbExists = false;
+    if (video.thumbPath) {
+      try {
+        await fs.promises.access(video.thumbPath, fs.constants.F_OK);
+        thumbExists = true;
+      } catch {
+        thumbExists = false;
+      }
     }
+    if (!video.thumbPath || !thumbExists) {
+      tempThumbPath = await this.ensureVideoThumb(video);
+    }
+
+    try {
+      if (peer.chatType === ChatType.KCHATTYPEGROUP) {
+        await this.uploadGroupVideo(+peer.peerUid, video);
+      } else if (peer.chatType === ChatType.KCHATTYPEC2C) {
+        await this.uploadC2CVideo(peer.peerUid, video);
+      } else {
+        throw new Error(`[Highway] unsupported chatType: ${peer.chatType}`);
+      }
+    } finally {
+      // 清理临时生成的缩略图文件
+      if (tempThumbPath) {
+        const thumbToClean = tempThumbPath;
+        fs.promises.unlink(thumbToClean)
+          .then(() => this.logger.debug(`[Highway] Cleaned up temp thumbnail: ${thumbToClean}`))
+          .catch((e) => {
+            // 文件不存在时忽略错误
+            if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {
+              this.logger.warn(`[Highway] Failed to clean up temp thumbnail: ${thumbToClean}, reason: ${e instanceof Error ? e.message : e}`);
+            }
+          });
+      }
+    }
+  }
+
+  /**
+   * 确保视频缩略图存在，如果不存在则自动生成
+   * @returns 生成的临时缩略图路径，用于后续清理
+   */
+  private async ensureVideoThumb (video: PacketMsgVideoElement): Promise<string> {
+    if (!video.filePath) {
+      throw new Error('video.filePath is empty, cannot generate thumbnail');
+    }
+
+    // 生成缩略图路径
+    const videoDir = path.dirname(video.filePath);
+    const videoBasename = path.basename(video.filePath, path.extname(video.filePath));
+    const thumbPath = path.join(videoDir, `${videoBasename}_thumb.png`);
+
+    this.logger.debug(`[Highway] Video thumb missing, generating at: ${thumbPath}`);
+
+    try {
+      // 尝试使用 FFmpeg 提取视频缩略图
+      await FFmpegService.extractThumbnail(video.filePath, thumbPath);
+      try {
+        await fs.promises.access(thumbPath, fs.constants.F_OK);
+        this.logger.debug('[Highway] Video thumbnail generated successfully using FFmpeg');
+      } catch {
+        throw new Error('FFmpeg failed to generate thumbnail');
+      }
+    } catch (e) {
+      // FFmpeg 失败时（包括未初始化的情况）使用默认缩略图
+      this.logger.warn(`[Highway] Failed to extract thumbnail, using default. Reason: ${e instanceof Error ? e.message : e}`);
+      await fs.promises.writeFile(thumbPath, Buffer.from(defaultVideoThumbB64, 'base64'));
+    }
+
+    // 更新视频元素的缩略图信息
+    video.thumbPath = thumbPath;
+    const thumbStat = await fs.promises.stat(thumbPath);
+    video.thumbSize = thumbStat.size;
+    video.thumbMd5 = await calculateFileMD5(thumbPath);
+    // 默认缩略图尺寸（与 defaultVideoThumbB64 匹配的尺寸）
+    if (!video.thumbWidth) video.thumbWidth = 240;
+    if (!video.thumbHeight) video.thumbHeight = 383;
+
+    this.logger.debug(`[Highway] Video thumb info set: path=${thumbPath}, size=${video.thumbSize}, md5=${video.thumbMd5}`);
+
+    return thumbPath;
   }
 
   async uploadPtt (peer: Peer, ptt: PacketMsgPttElement): Promise<void> {

packages/napcat-core/packet/message/builder.ts

@@ -14,7 +14,7 @@ export class PacketMsgBuilder {
 
   buildFakeMsg (selfUid: string, element: PacketMsg[]): NapProtoEncodeStructType<typeof PushMsgBody>[] {
     return element.map((node): NapProtoEncodeStructType<typeof PushMsgBody> => {
-      const avatar = `https://q.qlogo.cn/headimg_dl?dst_uin=${node.senderUin}&spec=640&img_type=jpg`;
+      const avatar = `https://q.qlogo.cn/headimg_dl?dst_uin=${node.senderUin}&spec=0&img_type=jpg`;
       const msgContent = node.msg.reduceRight((acc: undefined | Uint8Array, msg: IPacketMsgElement<PacketSendMsgElement>) => {
         return acc ?? msg.buildContent();
       }, undefined);

packages/napcat-core/packet/message/element.ts

@@ -510,15 +510,15 @@ export class PacketMsgPttElement extends IPacketMsgElement<SendPttElement> {
   }
 
   override buildElement (): NapProtoEncodeStructType<typeof Elem>[] {
-    return [];
-    // if (!this.msgInfo) return [];
-    // return [{
-    //     commonElem: {
-    //         serviceType: 48,
-    //         pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
-    //         businessType: 22,
-    //     }
-    // }];
+    //return [];
+    if (!this.msgInfo) return [];
+    return [{
+      commonElem: {
+        serviceType: 48,
+        pbElem: new NapProtoMsg(MsgInfo).encode(this.msgInfo),
+        businessType: 22,
+      }
+    }];
   }
 
   override toPreview (): string {

packages/napcat-core/services/NodeIKernelStorageCleanService.ts

@@ -3,39 +3,56 @@ import { GeneralCallResult } from './common';
 
 export interface NodeIKernelStorageCleanService {
 
-  addKernelStorageCleanListener(listener: NodeIKernelStorageCleanListener): number;
+  addKernelStorageCleanListener (listener: NodeIKernelStorageCleanListener): number;
 
-  removeKernelStorageCleanListener(listenerId: number): void;
+  removeKernelStorageCleanListener (listenerId: number): void;
+  // [
+  // "hotUpdate",
+  // [
+  //   "C:\\Users\\nanaeo\\AppData\\Roaming\\QQ\\packages"
+  // ]
+  // ],
+  // [
+  // "tmp",
+  // [
+  //   "C:\\Users\\nanaeo\\AppData\\Roaming\\QQ\\tmp"
+  // ]
+  // ],
+  // [
+  // "SilentCacheappSessionPartation9212",
+  // [
+  //   "C:\\Users\\nanaeo\\AppData\\Roaming\\QQ\\Partitions\\qqnt_9212"
+  // ]
+  // ]
+  addCacheScanedPaths (paths: Map<`tmp` | `SilentCacheappSessionPartation9212` | `hotUpdate`, unknown>): unknown;
 
-  addCacheScanedPaths(arg: unknown): unknown;
+  addFilesScanedPaths (arg: unknown): unknown;
 
-  addFilesScanedPaths(arg: unknown): unknown;
-
-  scanCache(): Promise<GeneralCallResult & {
-    size: string[]
+  scanCache (): Promise<GeneralCallResult & {
+    size: string[];
   }>;
 
-  addReportData(arg: unknown): unknown;
+  addReportData (arg: unknown): unknown;
 
-  reportData(): unknown;
+  reportData (): unknown;
 
-  getChatCacheInfo(arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown): unknown;
+  getChatCacheInfo (arg1: unknown, arg2: unknown, arg3: unknown, arg4: unknown): unknown;
 
-  getFileCacheInfo(arg1: unknown, arg2: unknown, arg3: unknown, arg44: unknown, args5: unknown): unknown;
+  getFileCacheInfo (arg1: unknown, arg2: unknown, arg3: unknown, arg44: unknown, args5: unknown): unknown;
 
-  clearChatCacheInfo(arg1: unknown, arg2: unknown): unknown;
+  clearChatCacheInfo (arg1: unknown, arg2: unknown): unknown;
 
-  clearCacheDataByKeys(arg: unknown): unknown;
+  clearCacheDataByKeys (keys: Array<string>): Promise<GeneralCallResult>;
 
-  setSilentScan(arg: unknown): unknown;
+  setSilentScan (is_silent: boolean): unknown;
 
-  closeCleanWindow(): unknown;
+  closeCleanWindow (): unknown;
 
-  clearAllChatCacheInfo(): unknown;
+  clearAllChatCacheInfo (): unknown;
 
-  endScan(arg: unknown): unknown;
+  endScan (arg: unknown): unknown;
 
-  addNewDownloadOrUploadFile(arg: unknown): unknown;
+  addNewDownloadOrUploadFile (arg: unknown): unknown;
 
-  isNull(): boolean;
+  isNull (): boolean;
 }

packages/napcat-core/types/msg.ts

@@ -181,7 +181,7 @@ export interface MessageElement {
   tofuRecordElement?: TofuRecordElement,
   taskTopMsgElement?: TaskTopMsgElement,
   recommendedMsgElement?: RecommendedMsgElement,
-  actionBarElement?: ActionBarElement
+  actionBarElement?: ActionBarElement;
 }
 
 /**
@@ -337,7 +337,7 @@ export interface InlineKeyboardElementRowButton {
  */
 export interface InlineKeyboardElement {
   rows: [{
-    buttons: InlineKeyboardElementRowButton[]
+    buttons: InlineKeyboardElementRowButton[];
   }],
   botAppid: string;
 }
@@ -441,14 +441,14 @@ export interface TipGroupElement {
       uid: string;
       card: string;
       name: string;
-      role: NTGroupMemberRole
+      role: NTGroupMemberRole;
     };
     member: {
-      uid: string
+      uid: string;
       card: string;
       name: string;
-      role: NTGroupMemberRole
-    }
+      role: NTGroupMemberRole;
+    };
   };
 }
 
@@ -498,6 +498,7 @@ export interface RawMessage {
   sendStatus?: SendStatusType;// 消息状态
   recallTime: string;// 撤回时间，"0" 是没有撤回
   records: RawMessage[];// 消息记录
+  emojiLikesList?: Array<{ emojiId: string; emojiType: string; likesCnt: string; isClicked: string; }>;
   elements: MessageElement[];// 消息元素
   sourceType: MsgSourceType;// 消息来源类型
   isOnlineMsg: boolean;// 是否为在线消息
@@ -508,9 +509,9 @@ export interface RawMessage {
  * 查询消息参数接口
  */
 export interface QueryMsgsParams {
-  chatInfo: Peer & { privilegeFlag?: number };
+  chatInfo: Peer & { privilegeFlag?: number; };
   // searchFields: number;
-  filterMsgType: Array<{ type: NTMsgType, subType: Array<number> }>;
+  filterMsgType: Array<{ type: NTMsgType, subType: Array<number>; }>;
   filterSendersUid: string[];
   filterMsgFromTime: string;
   filterMsgToTime: string;
@@ -554,7 +555,7 @@ export interface MsgReqType {
   queryOrder: boolean,
   includeSelf: boolean,
   includeDeleteMsg: boolean,
-  extraCnt: number
+  extraCnt: number;
 }
 
 /**

packages/napcat-core/types/webapi.ts

@@ -73,7 +73,7 @@ export interface WebApiGroupNoticeFeed {
   fn: number;
   cn: number;
   vn: number;
-  settings: {
+  settings?: {
     is_show_edit_card: number
     remind_ts: number
     tip_window_type: number

packages/napcat-develop/loadNapCat.cjs

@@ -73,6 +73,8 @@ async function copyAll () {
   process.env.NAPCAT_QQ_PACKAGE_INFO_PATH = path.join(TARGET_DIR, 'package.json');
   process.env.NAPCAT_QQ_VERSION_CONFIG_PATH = path.join(TARGET_DIR, 'config.json');
   process.env.NAPCAT_DISABLE_PIPE = '1';
+  // 禁用重启和多进程功能
+  process.env.NAPCAT_DISABLE_MULTI_PROCESS = '1';
   process.env.NAPCAT_WORKDIR = TARGET_DIR;
   // 开发环境使用固定密钥
   process.env.NAPCAT_WEBUI_JWT_SECRET_KEY = 'napcat_dev_secret_key';

packages/napcat-framework/napcat.ts

@@ -8,6 +8,8 @@ import { QQBasicInfoWrapper } from '@/napcat-core/helper/qq-basic-info';
 import { InstanceContext, loadQQWrapper, NapCatCore, NapCatCoreWorkingEnv, NodeIKernelLoginListener, NodeIKernelLoginService, NodeIQQNTWrapperSession, SelfInfo, WrapperNodeApi } from '@/napcat-core';
 import { proxiedListenerOf } from '@/napcat-core/helper/proxy-handler';
 import { statusHelperSubscription } from '@/napcat-core/helper/status';
+import { applyPendingUpdates } from '@/napcat-webui-backend/src/api/UpdateNapCat';
+import { WebUiDataRuntime } from '@/napcat-webui-backend/src/helper/Data';
 
 // Framework ES入口文件
 export async function getWebUiUrl () {
@@ -32,7 +34,9 @@ export async function NCoreInitFramework (
   });
 
   const pathWrapper = new NapCatPathWrapper();
+
   const logger = new LogWrapper(pathWrapper.logsPath);
+  await applyPendingUpdates(pathWrapper, logger);
   const basicInfoWrapper = new QQBasicInfoWrapper({ logger });
   const wrapper = loadQQWrapper(basicInfoWrapper.getFullQQVersion());
   const nativePacketHandler = new NativePacketHandler({ logger }); // 初始化 NativePacketHandler 用于后续使用
@@ -69,13 +73,17 @@ export async function NCoreInitFramework (
   // 过早进入会导致addKernelMsgListener等Listener添加失败
   // await sleep(2500);
   // 初始化 NapCatFramework
-  const loaderObject = new NapCatFramework(wrapper, session, logger, loginService, selfInfo, basicInfoWrapper, pathWrapper, nativePacketHandler);
+  const loaderObject = new NapCatFramework(wrapper, session, logger, selfInfo, basicInfoWrapper, pathWrapper, nativePacketHandler);
   await loaderObject.core.initCore();
 
   // 启动WebUi
+  WebUiDataRuntime.setWorkingEnv(NapCatCoreWorkingEnv.Framework);
   InitWebUi(logger, pathWrapper, logSubscription, statusHelperSubscription).then().catch(e => logger.logError(e));
   // 初始化LLNC的Onebot实现
-  await new NapCatOneBot11Adapter(loaderObject.core, loaderObject.context, pathWrapper).InitOneBot();
+  const oneBotAdapter = new NapCatOneBot11Adapter(loaderObject.core, loaderObject.context, pathWrapper);
+  // 注册到 WebUiDataRuntime，供调试功能使用
+  WebUiDataRuntime.setOneBotContext(oneBotAdapter);
+  await oneBotAdapter.InitOneBot();
 }
 
 export class NapCatFramework {
@@ -86,7 +94,6 @@ export class NapCatFramework {
     wrapper: WrapperNodeApi,
     session: NodeIQQNTWrapperSession,
     logger: LogWrapper,
-    loginService: NodeIKernelLoginService,
     selfInfo: SelfInfo,
     basicInfoWrapper: QQBasicInfoWrapper,
     pathWrapper: NapCatPathWrapper,
@@ -98,7 +105,6 @@ export class NapCatFramework {
       wrapper,
       session,
       logger,
-      loginService,
       basicInfoWrapper,
       pathWrapper,
     };

packages/napcat-framework/vite.config.ts

@@ -8,7 +8,6 @@ import react from '@vitejs/plugin-react-swc';
 import napcatVersion from 'napcat-vite/vite-plugin-version.js';
 // 依赖排除
 const external = [
-  'silk-wasm',
   'ws',
   'express',
 ];
@@ -60,7 +59,6 @@ const FrameworkBaseConfig = () =>
       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'],

packages/napcat-onebot/action/extends/ShareContact.ts

@@ -6,23 +6,23 @@ import { Static, Type } from '@sinclair/typebox';
 const SchemaData = Type.Object({
   user_id: Type.Optional(Type.Union([Type.Number(), Type.String()])),
   group_id: Type.Optional(Type.Union([Type.Number(), Type.String()])),
-  phoneNumber: Type.String({ default: '' }),
+  phone_number: Type.String({ default: '' }),
 });
 
 type Payload = Static<typeof SchemaData>;
 
-export class SharePeer extends OneBotAction<Payload, GeneralCallResult & {
+export class SharePeerBase extends OneBotAction<Payload, GeneralCallResult & {
   arkMsg?: string;
   arkJson?: string;
 }> {
-  override actionName = ActionName.SharePeer;
+
   override payloadSchema = SchemaData;
 
   async _handle (payload: Payload) {
     if (payload.group_id) {
       return await this.core.apis.GroupApi.getGroupRecommendContactArkJson(payload.group_id.toString());
     } else if (payload.user_id) {
-      return await this.core.apis.UserApi.getBuddyRecommendContactArkJson(payload.user_id.toString(), payload.phoneNumber);
+      return await this.core.apis.UserApi.getBuddyRecommendContactArkJson(payload.user_id.toString(), payload.phone_number);
     }
     throw new Error('group_id or user_id is required');
   }
@@ -31,14 +31,25 @@ export class SharePeer extends OneBotAction<Payload, GeneralCallResult & {
 const SchemaDataGroupEx = Type.Object({
   group_id: Type.Union([Type.Number(), Type.String()]),
 });
-
+export class SharePeer extends SharePeerBase {
+  override actionName = ActionName.SharePeer;
+}
 type PayloadGroupEx = Static<typeof SchemaDataGroupEx>;
 
-export class ShareGroupEx extends OneBotAction<PayloadGroupEx, string> {
-  override actionName = ActionName.ShareGroupEx;
+export class ShareGroupExBase extends OneBotAction<PayloadGroupEx, string> {
   override payloadSchema = SchemaDataGroupEx;
 
   async _handle (payload: PayloadGroupEx) {
     return await this.core.apis.GroupApi.getArkJsonGroupShare(payload.group_id.toString());
   }
 }
+export class ShareGroupEx extends ShareGroupExBase {
+  override actionName = ActionName.ShareGroupEx;
+}
+export class SendGroupArkShare extends ShareGroupExBase {
+  override actionName = ActionName.SendGroupArkShare;
+}
+
+export class SendArkShare extends SharePeerBase {
+  override actionName = ActionName.SendArkShare;
+}

packages/napcat-onebot/action/file/GetRecord.ts

@@ -1,7 +1,6 @@
 import { GetFileBase, GetFilePayload, GetFileResponse } from './GetFile';
 import { ActionName } from '@/napcat-onebot/action/router';
 import { promises as fs } from 'fs';
-import { decode } from 'silk-wasm';
 import { FFmpegService } from '@/napcat-core/helper/ffmpeg/ffmpeg';
 
 const out_format = ['mp3', 'amr', 'wma', 'm4a', 'spx', 'ogg', 'wav', 'flac'];
@@ -21,19 +20,13 @@ export default class GetRecord extends GetFileBase {
       if (!out_format.includes(payload.out_format)) {
         throw new Error('转换失败 out_format 字段可能格式不正确');
       }
-      const pcmFile = `${inputFile}.pcm`;
       const outputFile = `${inputFile}.${payload.out_format}`;
       try {
         await fs.access(inputFile);
         try {
           await fs.access(outputFile);
         } catch {
-          if (FFmpegService.getAdapterName() === 'FFmpegAddon') {
-            await FFmpegService.convertFile(inputFile, outputFile, payload.out_format);
-          } else {
-            await this.decodeFile(inputFile, pcmFile);
-            await FFmpegService.convertFile(pcmFile, outputFile, payload.out_format);
-          }
+          await FFmpegService.convertAudioFmt(inputFile, outputFile, payload.out_format);
         }
         const base64Data = await fs.readFile(outputFile, { encoding: 'base64' });
         res.file = outputFile;
@@ -46,15 +39,4 @@ export default class GetRecord extends GetFileBase {
     }
     return res;
   }
-
-  private async decodeFile (inputFile: string, outputFile: string): Promise<void> {
-    try {
-      const inputData = await fs.readFile(inputFile);
-      const decodedData = await decode(inputData, 24000);
-      await fs.writeFile(outputFile, Buffer.from(decodedData.data));
-    } catch (error) {
-      console.error('Error decoding file:', error);
-      throw error; // 重新抛出错误以便调用者可以处理
-    }
-  }
 }

packages/napcat-onebot/action/go-cqhttp/GetForwardMsg.ts

@@ -100,7 +100,7 @@ export class GoCQHTTPGetForwardMsgAction extends OneBotAction<Payload, {
 
     // 3. 定义协议回退逻辑函数
     const protocolFallbackLogic = async (resId: string) => {
-      const ob = (await this.obContext.apis.MsgApi.parseMessageV2(createFakeForwardMsg(resId)))?.arrayMsg;
+      const ob = (await this.obContext.apis.MsgApi.parseMessageV2(createFakeForwardMsg(resId), true))?.arrayMsg;
       if (ob) {
         return {
           messages: (ob?.message?.[0] as OB11MessageForward)?.data?.content,
@@ -122,7 +122,7 @@ export class GoCQHTTPGetForwardMsgAction extends OneBotAction<Payload, {
 
     if (rootMsg) {
       // 5. 获取消息内容
-      const data = await this.core.apis.MsgApi.getMsgsByMsgId(rootMsg.Peer, [rootMsg.MsgId]);
+      const data = await this.core.apis.MsgApi.getMsgHistory(rootMsg.Peer, rootMsg.MsgId, 1);//getMsgsIncludeSelf
 
       if (data && data.result === 0 && data.msgList.length > 0) {
         const singleMsg = data.msgList[0];

packages/napcat-onebot/action/go-cqhttp/GetFriendMsgHistory.ts

@@ -14,10 +14,11 @@ const SchemaData = Type.Object({
   user_id: Type.String(),
   message_seq: Type.Optional(Type.String()),
   count: Type.Number({ default: 20 }),
-  reverseOrder: Type.Boolean({ default: false }),
+  reverse_order: Type.Boolean({ default: false }),
   disable_get_url: Type.Boolean({ default: false }),
   parse_mult_msg: Type.Boolean({ default: true }),
   quick_reply: Type.Boolean({ default: false }),
+  reverseOrder: Type.Boolean({ default: false }),// @deprecated 兼容旧版本
 });
 
 type Payload = Static<typeof SchemaData>;
@@ -35,7 +36,7 @@ export default class GetFriendMsgHistory extends OneBotAction<Payload, Response>
     const hasMessageSeq = !payload.message_seq ? !!payload.message_seq : !(payload.message_seq?.toString() === '' || payload.message_seq?.toString() === '0');
     const startMsgId = hasMessageSeq ? (MessageUnique.getMsgIdAndPeerByShortId(+payload.message_seq!)?.MsgId ?? payload.message_seq!.toString()) : '0';
     const msgList = hasMessageSeq
-      ? (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count, payload.reverseOrder)).msgList
+      ? (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count, payload.reverse_order || payload.reverseOrder)).msgList
       : (await this.core.apis.MsgApi.getAioFirstViewLatestMsgs(peer, +payload.count)).msgList;
     if (msgList.length === 0) throw new Error(`消息${payload.message_seq}不存在`);
     // 转换序号

packages/napcat-onebot/action/go-cqhttp/GetGroupMsgHistory.ts

@@ -14,10 +14,11 @@ const SchemaData = Type.Object({
   group_id: Type.String(),
   message_seq: Type.Optional(Type.String()),
   count: Type.Number({ default: 20 }),
-  reverseOrder: Type.Boolean({ default: false }),
+  reverse_order: Type.Boolean({ default: false }),
   disable_get_url: Type.Boolean({ default: false }),
   parse_mult_msg: Type.Boolean({ default: true }),
   quick_reply: Type.Boolean({ default: false }),
+  reverseOrder: Type.Boolean({ default: false }),// @deprecated 兼容旧版本
 });
 
 type Payload = Static<typeof SchemaData>;
@@ -32,7 +33,7 @@ export default class GoCQHTTPGetGroupMsgHistory extends OneBotAction<Payload, Re
     // 拉取消息
     const startMsgId = hasMessageSeq ? (MessageUnique.getMsgIdAndPeerByShortId(+payload.message_seq!)?.MsgId ?? payload.message_seq!.toString()) : '0';
     const msgList = hasMessageSeq
-      ? (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count, payload.reverseOrder)).msgList
+      ? (await this.core.apis.MsgApi.getMsgHistory(peer, startMsgId, +payload.count, payload.reverse_order || payload.reverseOrder)).msgList
       : (await this.core.apis.MsgApi.getAioFirstViewLatestMsgs(peer, +payload.count)).msgList;
     if (msgList.length === 0) throw new Error(`消息${payload.message_seq}不存在`);
     // 转换序号

packages/napcat-onebot/action/go-cqhttp/UploadGroupFile.ts

@@ -12,6 +12,7 @@ const SchemaData = Type.Object({
   name: Type.String(),
   folder: Type.Optional(Type.String()),
   folder_id: Type.Optional(Type.String()), // 临时扩展
+  upload_file: Type.Boolean({ default: true }),
 });
 
 type Payload = Static<typeof SchemaData>;
@@ -41,7 +42,7 @@ export default class GoCQHTTPUploadGroupFile extends OneBotAction<Payload, Uploa
       peer,
       deleteAfterSentFiles: [],
     };
-    const sendFileEle = await this.obContext.apis.FileApi.createValidSendFileElement(msgContext, downloadResult.path, payload.name, payload.folder ?? payload.folder_id);
+    const sendFileEle = await this.obContext.apis.FileApi.createValidSendFileElement(msgContext, downloadResult.path, payload.name, payload.folder ?? payload.folder_id, payload.upload_file);
     msgContext.deleteAfterSentFiles.push(downloadResult.path);
     const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(peer, [sendFileEle], msgContext.deleteAfterSentFiles);
 

packages/napcat-onebot/action/go-cqhttp/UploadPrivateFile.ts

@@ -11,6 +11,7 @@ const SchemaData = Type.Object({
   user_id: Type.Union([Type.Number(), Type.String()]),
   file: Type.String(),
   name: Type.String(),
+  upload_file: Type.Boolean({ default: true }),
 });
 
 type Payload = Static<typeof SchemaData>;
@@ -51,7 +52,7 @@ export default class GoCQHTTPUploadPrivateFile extends OneBotAction<Payload, Upl
       }, ContextMode.Private),
       deleteAfterSentFiles: [],
     };
-    const sendFileEle: SendFileElement = await this.obContext.apis.FileApi.createValidSendFileElement(msgContext, downloadResult.path, payload.name);
+    const sendFileEle: SendFileElement = await this.obContext.apis.FileApi.createValidSendFileElement(msgContext, downloadResult.path, payload.name, '', payload.upload_file);
     msgContext.deleteAfterSentFiles.push(downloadResult.path);
     const returnMsg = await this.obContext.apis.MsgApi.sendMsgWithOb11UniqueId(await this.getPeer(payload), [sendFileEle], msgContext.deleteAfterSentFiles);
 

packages/napcat-onebot/action/group/GetGroupNotice.ts

@@ -7,19 +7,26 @@ interface GroupNotice {
   publish_time: number;
   notice_id: string;
   message: {
-    text: string
+    text: string;
     // 保持一段时间兼容性 防止以往版本出现问题 后续版本可考虑移除
     image: Array<{
-      height: string
-      width: string
-      id: string
+      height: string;
+      width: string;
+      id: string;
     }>,
     images: Array<{
-      height: string
-      width: string
-      id: string
-    }>
+      height: string;
+      width: string;
+      id: string;
+    }>;
   };
+  settings?: {
+    is_show_edit_card: number,
+    remind_ts: number,
+    tip_window_type: number,
+    confirm_required: number;
+  };
+  read_num?: number;
 }
 
 const SchemaData = Type.Object({
@@ -59,6 +66,8 @@ export class GetGroupNotice extends OneBotAction<Payload, GroupNotice[]> {
           image,
           images: image,
         },
+        settings: retApiNotice.settings,
+        read_num: retApiNotice.read_num
       };
       retNotices.push(retNotice);
     }

packages/napcat-onebot/action/index.ts

@@ -54,7 +54,7 @@ import { GetOnlineClient } from './go-cqhttp/GetOnlineClient';
 import { IOCRImage, OCRImage } from './extends/OCRImage';
 import { TranslateEnWordToZn } from './extends/TranslateEnWordToZn';
 import { SetQQProfile } from './go-cqhttp/SetQQProfile';
-import { ShareGroupEx, SharePeer } from './extends/ShareContact';
+import { SendArkShare, SendGroupArkShare, ShareGroupEx, SharePeer } from './extends/ShareContact';
 import { CreateCollection } from './extends/CreateCollection';
 import { SetLongNick } from './extends/SetLongNick';
 import DelEssenceMsg from './group/DelEssenceMsg';
@@ -67,6 +67,8 @@ import GoCQHTTPUploadPrivateFile from './go-cqhttp/UploadPrivateFile';
 import { FetchEmojiLike } from './extends/FetchEmojiLike';
 import { NapCatCore } from 'napcat-core';
 import { NapCatOneBot11Adapter } from '@/napcat-onebot/index';
+import type { NetworkAdapterConfig } from '../config/config';
+import { OneBotAction } from './OneBotAction';
 import { SetInputStatus } from './extends/SetInputStatus';
 import { GetCSRF } from './system/GetCSRF';
 import { DelGroupNotice } from './group/DelGroupNotice';
@@ -86,6 +88,7 @@ import { GetGroupMemberList } from './group/GetGroupMemberList';
 import { GetGroupFileUrl } from '@/napcat-onebot/action/file/GetGroupFileUrl';
 import { GetPacketStatus } from '@/napcat-onebot/action/packet/GetPacketStatus';
 import { GetCredentials } from './system/GetCredentials';
+import { SetRestart } from './system/SetRestart';
 import { SendGroupSign, SetGroupSign } from './extends/SetGroupSign';
 import { GoCQHTTPGetGroupAtAllRemain } from './go-cqhttp/GetGroupAtAllRemain';
 import { GoCQHTTPCheckUrlSafely } from './go-cqhttp/GoCQHTTPCheckUrlSafely';
@@ -170,6 +173,8 @@ export function createActionMap (obContext: NapCatOneBot11Adapter, core: NapCatC
     new SetQQProfile(obContext, core),
     new ShareGroupEx(obContext, core),
     new SharePeer(obContext, core),
+    new SendGroupArkShare(obContext, core),
+    new SendArkShare(obContext, core),
     new CreateCollection(obContext, core),
     new SetLongNick(obContext, core),
     new ForwardFriendSingleMsg(obContext, core),
@@ -264,6 +269,7 @@ export function createActionMap (obContext: NapCatOneBot11Adapter, core: NapCatC
     new GetGroupFileSystemInfo(obContext, core),
     new GetGroupFilesByFolder(obContext, core),
     new GetPacketStatus(obContext, core),
+    new SetRestart(obContext, core),
     new GroupPoke(obContext, core),
     new FriendPoke(obContext, core),
     new GetUserStatus(obContext, core),
@@ -318,6 +324,30 @@ export function createActionMap (obContext: NapCatOneBot11Adapter, core: NapCatC
   function get<K extends keyof MapType> (key: K): MapType[K] | undefined {
     return _map.get(key as keyof MapType) as MapType[K] | undefined;
   }
-  return { get };
+
+  /**
+   * 类型安全的 action 调用辅助函数
+   * 根据 action 名称自动推导返回类型
+   */
+  async function call<K extends keyof MapType> (
+    actionName: K,
+    params: unknown,
+    adapter: string,
+    config: NetworkAdapterConfig
+  ): Promise<MapType[K] extends OneBotAction<any, infer R> ? R : never> {
+    const action = _map.get(actionName);
+    if (!action) {
+      throw new Error(`Action ${String(actionName)} not found`);
+    }
+
+    const result = await (action as any).handle(params, adapter, config);
+    if (result.status !== 'ok' || !result.data) {
+      throw new Error(`Action ${String(actionName)} failed: ${result.message || 'No data returned'}`);
+    }
+
+    return result.data;
+  }
+
+  return { get, call };
 }
 export type ActionMap = ReturnType<typeof createActionMap>;

packages/napcat-onebot/action/msg/GetMsg.ts

@@ -36,6 +36,15 @@ class GetMsg extends OneBotAction<Payload, OB11Message> {
     if (!msg) throw Error('消息不存在');
     const retMsg = await this.obContext.apis.MsgApi.parseMessage(msg, config.messagePostFormat);
     if (!retMsg) throw Error('消息为空');
+    retMsg.emoji_likes_list = [];
+    msg.emojiLikesList?.map(emoji => {
+      retMsg.emoji_likes_list?.push({
+        emoji_id: emoji.emojiId,
+        emoji_type: emoji.emojiType,
+        likes_cnt: emoji.likesCnt,
+      });
+    });
+    // 烘焙emoji_likes_list 仅此处烘焙
     try {
       retMsg.message_id = MessageUnique.createUniqueMsgId(peer, msg.msgId)!;
       retMsg.message_seq = retMsg.message_id;

packages/napcat-onebot/action/msg/SendMsg.ts

@@ -317,11 +317,11 @@ export class SendMsgBase extends OneBotAction<OB11PostSendMsg, ReturnDataType> {
 
           const MixElement = sendElements.filter(
             element =>
-              element.elementType !== ElementType.FILE && element.elementType !== ElementType.VIDEO && element.elementType !== ElementType.ARK
+              element.elementType !== ElementType.FILE && element.elementType !== ElementType.VIDEO && element.elementType !== ElementType.ARK && element.elementType !== ElementType.PTT
           );
           const SingleElement = sendElements.filter(
             element =>
-              element.elementType === ElementType.FILE || element.elementType === ElementType.VIDEO || element.elementType === ElementType.ARK
+              element.elementType === ElementType.FILE || element.elementType === ElementType.VIDEO || element.elementType === ElementType.ARK || element.elementType === ElementType.PTT
           ).map(e => [e]);
 
           const AllElement: SendMessageElement[][] = [MixElement, ...SingleElement].filter(e => e !== undefined && e.length !== 0);

packages/napcat-onebot/action/router.ts

@@ -81,7 +81,7 @@ export const ActionName = {
   CanSendRecord: 'can_send_record',
   GetStatus: 'get_status',
   GetVersionInfo: 'get_version_info',
-  // Reboot : 'set_restart',
+  Reboot: 'set_restart',
   CleanCache: 'clean_cache',
   Exit: 'bot_exit',
   // go-cqhttp
@@ -125,8 +125,11 @@ export const ActionName = {
   // 以下为扩展napcat扩展
   Unknown: 'unknown',
   SetDiyOnlineStatus: 'set_diy_online_status',
-  SharePeer: 'ArkSharePeer',
-  ShareGroupEx: 'ArkShareGroup',
+  SharePeer: 'ArkSharePeer',// @deprecated
+  ShareGroupEx: 'ArkShareGroup',// @deprecated
+  // 标准化接口
+  SendGroupArkShare: 'send_group_ark_share',
+  SendArkShare: 'send_ark_share',
   // RebootNormal : 'reboot_normal', //无快速登录重新启动
   GetRobotUinRange: 'get_robot_uin_range',
   SetOnlineStatus: 'set_online_status',

packages/napcat-onebot/action/stream/DownloadFileRecordStream.ts

@@ -4,7 +4,6 @@ import { Static, Type } from '@sinclair/typebox';
 import { NetworkAdapterConfig } from '@/napcat-onebot/config/config';
 import { StreamPacket, StreamStatus } from './StreamBasic';
 import fs from 'fs';
-import { decode } from 'silk-wasm';
 import { FFmpegService } from '@/napcat-core/helper/ffmpeg/ffmpeg';
 import { BaseDownloadStream, DownloadResult } from './BaseDownloadStream';
 
@@ -38,7 +37,6 @@ export class DownloadFileRecordStream extends BaseDownloadStream<Payload, Downlo
           throw new Error('转换失败 out_format 字段可能格式不正确');
         }
 
-        const pcmFile = `${downloadPath}.pcm`;
         const outputFile = `${downloadPath}.${payload.out_format}`;
 
         try {
@@ -46,13 +44,8 @@ export class DownloadFileRecordStream extends BaseDownloadStream<Payload, Downlo
           await fs.promises.access(outputFile);
           streamPath = outputFile;
         } catch {
-          // 尝试解码 silk 到 pcm 再用 ffmpeg 转换
-          if (FFmpegService.getAdapterName() === 'FFmpegAddon') {
-            await FFmpegService.convertFile(downloadPath, outputFile, payload.out_format);
-          } else {
-            await this.decodeFile(downloadPath, pcmFile);
-            await FFmpegService.convertFile(pcmFile, outputFile, payload.out_format);
-          }
+          // 尝试解码 amr 到 out format直接 ffmpeg 转换
+          await FFmpegService.convertAudioFmt(downloadPath, outputFile, payload.out_format);
           streamPath = outputFile;
         }
       }
@@ -82,15 +75,4 @@ export class DownloadFileRecordStream extends BaseDownloadStream<Payload, Downlo
       throw new Error(`Download failed: ${(error as Error).message}`);
     }
   }
-
-  private async decodeFile (inputFile: string, outputFile: string): Promise<void> {
-    try {
-      const inputData = await fs.promises.readFile(inputFile);
-      const decodedData = await decode(inputData, 24000);
-      await fs.promises.writeFile(outputFile, Buffer.from(decodedData.data));
-    } catch (error) {
-      console.error('Error decoding file:', error);
-      throw error;
-    }
-  }
 }

packages/napcat-onebot/action/system/SetRestart.ts

@@ -0,0 +1,14 @@
+import { ActionName } from '@/napcat-onebot/action/router';
+import { OneBotAction } from '../OneBotAction';
+import { WebUiDataRuntime } from 'napcat-webui-backend/src/helper/Data';
+
+export class SetRestart extends OneBotAction<void, void> {
+  override actionName = ActionName.Reboot;
+
+  async _handle () {
+    const result = await WebUiDataRuntime.requestRestartProcess();
+    if (!result.result) {
+      throw new Error(result.message || '进程重启失败');
+    }
+  }
+}

packages/napcat-onebot/api/file.ts

@@ -19,16 +19,18 @@ export class OneBotFileApi {
     this.core = core;
   }
 
-  async createValidSendFileElement (context: SendMessageContext, filePath: string, fileName: string = '', folderId: string = ''): Promise<SendFileElement> {
+  async createValidSendFileElement (context: SendMessageContext, filePath: string, fileName: string = '', folderId: string = '', uploadGroupFile: boolean = false): Promise<SendFileElement> {
     const {
       fileName: _fileName,
       path,
       fileSize,
-    } = await this.core.apis.FileApi.uploadFile(filePath, ElementType.FILE);
+    } = await this.core.apis.FileApi.uploadFile(filePath, ElementType.FILE, 0, uploadGroupFile);
     if (fileSize === 0) {
       throw new Error('文件异常，大小为0');
     }
-    context.deleteAfterSentFiles.push(path);
+    if (uploadGroupFile) {
+      context.deleteAfterSentFiles.push(path);
+    }
     return {
       elementType: ElementType.FILE,
       elementId: '',

packages/napcat-onebot/api/group.ts

@@ -19,6 +19,7 @@ import { OB11GroupCardEvent } from '@/napcat-onebot/event/notice/OB11GroupCardEv
 import { OB11GroupPokeEvent } from '@/napcat-onebot/event/notice/OB11PokeEvent';
 import { OB11GroupEssenceEvent } from '@/napcat-onebot/event/notice/OB11GroupEssenceEvent';
 import { OB11GroupTitleEvent } from '@/napcat-onebot/event/notice/OB11GroupTitleEvent';
+import { OB11GroupGrayTipEvent } from '@/napcat-onebot/event/notice/OB11GroupGrayTipEvent';
 import { OB11GroupUploadNoticeEvent } from '../event/notice/OB11GroupUploadNoticeEvent';
 import { OB11GroupNameEvent } from '../event/notice/OB11GroupNameEvent';
 import { FileNapCatOneBotUUID } from 'napcat-common/src/file-uuid';
@@ -174,7 +175,6 @@ export class OneBotGroupApi {
 
   async registerParseGroupReactEventByCore () {
     this.core.event.on('event:emoji_like', async (data) => {
-      console.log('Received emoji_like event from core:', data);
       const event = await this.createGroupEmojiLikeEvent(
         data.groupId,
         data.senderUin,
@@ -207,15 +207,24 @@ export class OneBotGroupApi {
     }
     return undefined;
   }
-
-  async parseOtherJsonEvent (msg: RawMessage, jsonStr: string, context: InstanceContext) {
-    const json = JSON.parse(jsonStr);
-    const type = json.items[json.items.length - 1]?.txt;
+  async parseOtherJsonEvent (msg: RawMessage, jsonGrayTipElement: GrayTipElement['jsonGrayTipElement'], context: InstanceContext) {
+    let json: { items?: { txt?: string; param?: string[] }[] };
+    try {
+      json = JSON.parse(jsonGrayTipElement.jsonStr);
+    } catch (e) {
+      context.logger.logWarn('灰条消息JSON解析失败', jsonGrayTipElement.jsonStr, e);
+      return undefined;
+    }
+    const type = json.items?.[json.items.length - 1]?.txt;
     await this.core.apis.GroupApi.refreshGroupMemberCachePartial(msg.peerUid, msg.senderUid);
     if (type === '头衔') {
-      const memberUin = json.items[1].param[0];
-      const title = json.items[3].txt;
+      const memberUin = json.items?.[1]?.param?.[0];
+      const title = json.items?.[3]?.txt;
       context.logger.logDebug('收到群成员新头衔消息', json);
+      if (memberUin == null || title == null) {
+        context.logger.logWarn('收到格式异常的群成员新头衔灰条消息', json);
+        return undefined;
+      }
       return new OB11GroupTitleEvent(
         this.core,
         +msg.peerUid,
@@ -226,6 +235,27 @@ export class OneBotGroupApi {
       context.logger.logDebug('收到机器人被踢消息', json);
     } else {
       context.logger.logWarn('收到未知的灰条消息', json);
+
+      // 如果有真实发送者（非0），生成事件上报，可用于检测和撤回伪造灰条
+      const senderUin = Number(msg.senderUin) || 0;
+      if (senderUin !== 0) {
+        const peer = { chatType: ChatType.KCHATTYPEGROUP, guildId: '', peerUid: msg.peerUid };
+        const messageId = MessageUnique.createUniqueMsgId(peer, msg.msgId);
+        return new OB11GroupGrayTipEvent(
+          this.core,
+          +msg.peerUin,
+          senderUin,
+          messageId,
+          jsonGrayTipElement.busiId,
+          jsonGrayTipElement.jsonStr,
+          {
+            msgSeq: msg.msgSeq,
+            msgTime: msg.msgTime,
+            msgId: msg.msgId,
+            json,
+          }
+        );
+      }
     }
     return undefined;
   }
@@ -377,7 +407,7 @@ export class OneBotGroupApi {
         return await this.parse51TypeEvent(msg, grayTipElement);
       } else {
         console.log('Unknown JSON event:', grayTipElement.jsonGrayTipElement, JSON.stringify(grayTipElement));
-        return await this.parseOtherJsonEvent(msg, grayTipElement.jsonGrayTipElement.jsonStr, this.core.context);
+        return await this.parseOtherJsonEvent(msg, grayTipElement.jsonGrayTipElement, this.core.context);
       }
     }
     return undefined;

packages/napcat-onebot/api/msg.ts

@@ -749,26 +749,31 @@ export class OneBotMsgApi {
 
     [OB11MessageDataType.music]: async ({ data }, context) => {
       // 保留, 直到...找到更好的解决方案
+      const supportedPlatforms = ['qq', '163', 'kugou', 'kuwo', 'migu'];
+      const supportedPlatformsWithCustom = [...supportedPlatforms, 'custom'];
+
+      // 验证音乐类型
       if (data.id !== undefined) {
-        if (!['qq', '163', 'kugou', 'kuwo', 'migu'].includes(data.type)) {
-          this.core.context.logger.logError('音乐卡片type错误, 只支持qq、163、kugou、kuwo、migu，当前type:', data.type);
+        if (!supportedPlatforms.includes(data.type)) {
+          this.core.context.logger.logError(`[音乐卡片] type参数错误: "${data.type}"，仅支持: ${supportedPlatforms.join('、')}`);
           return undefined;
         }
       } else {
-        if (!['qq', '163', 'kugou', 'kuwo', 'migu', 'custom'].includes(data.type)) {
-          this.core.context.logger.logError('音乐卡片type错误, 只支持qq、163、kugou、kuwo、migu、custom，当前type:', data.type);
+        if (!supportedPlatformsWithCustom.includes(data.type)) {
+          this.core.context.logger.logError(`[音乐卡片] type参数错误: "${data.type}"，仅支持: ${supportedPlatformsWithCustom.join('、')}`);
           return undefined;
         }
         if (!data.url) {
-          this.core.context.logger.logError('自定义音卡缺少参数url');
+          this.core.context.logger.logError('[音乐卡片] 自定义音乐卡片缺少必需参数: url');
           return undefined;
         }
         if (!data.image) {
-          this.core.context.logger.logError('自定义音卡缺少参数image');
+          this.core.context.logger.logError('[音乐卡片] 自定义音乐卡片缺少必需参数: image');
           return undefined;
         }
       }
 
+      // 构建请求数据
       let postData: IdMusicSignPostData | CustomMusicSignPostData;
       if (data.id === undefined && data.content) {
         const { content, ...others } = data;
@@ -776,11 +781,14 @@ export class OneBotMsgApi {
       } else {
         postData = data;
       }
+
+      // 获取签名服务地址
       let signUrl = this.obContext.configLoader.configData.musicSignUrl;
       if (!signUrl) {
         signUrl = 'https://ss.xingzhige.com/music_card/card';// 感谢思思！已获思思许可 其余地方使用请自行询问
-        // throw Error('音乐消息签名地址未配置');
       }
+
+      // 请求签名服务
       try {
         const musicJson = await RequestUtil.HttpGetJson<string>(signUrl, 'POST', postData);
         return this.ob11ToRawConverters.json({
@@ -788,9 +796,16 @@ export class OneBotMsgApi {
           type: OB11MessageDataType.json,
         }, context);
       } catch (e) {
-        this.core.context.logger.logError('生成音乐消息失败', e);
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        this.core.context.logger.logError(
+          '[音乐卡片签名失败] 签名服务请求出错!\n' +
+          `  ├─ 音乐类型: ${data.type}\n` +
+          `  ├─ 音乐ID: ${data.id ?? '自定义'}\n` +
+          `  ├─ 错误信息: ${errorMessage}\n` +
+          '  └─ 提示: 请检查网络连接，或尝试在配置中更换其他音乐签名服务地址(musicSignUrl)'
+        );
+        return undefined;
       }
-      return undefined;
     },
 
     [OB11MessageDataType.node]: async () => undefined,
@@ -969,8 +984,20 @@ export class OneBotMsgApi {
     disableGetUrl: boolean = false,
     quick_reply: boolean = false
   ) {
-    if (msg.senderUin === '0' || msg.senderUin === '') return;
-    if (msg.peerUin === '0' || msg.peerUin === '') return;
+    if ((msg.senderUin === '0' || msg.senderUin === '')) {
+      if (msg.senderUid && msg.senderUid !== '' && msg.senderUid !== '0') {
+        msg.senderUin = await this.core.apis.UserApi.getUinByUidV2(msg.senderUid);
+      } else {
+        return undefined;
+      }
+    }
+    if (msg.peerUin === '0' || msg.peerUin === '') {
+      if (msg.peerUid && msg.peerUid !== '' && msg.peerUid !== '0') {
+        msg.peerUin = await this.core.apis.UserApi.getUinByUidV2(msg.peerUid);
+      } else {
+        return undefined;
+      }
+    }
 
     const resMsg = this.initializeMessage(msg);
 
@@ -1048,7 +1075,8 @@ export class OneBotMsgApi {
     resMsg.sub_type = 'group';
     const ret = await this.core.apis.MsgApi.getTempChatInfo(ChatType.KCHATTYPETEMPC2CFROMGROUP, msg.senderUid);
     if (ret.result === 0) {
-      const member = await this.core.apis.GroupApi.getGroupMember(msg.peerUin, msg.senderUin);
+      // 避免uin:'' uid非空，uid一般不空
+      const member = await this.core.apis.GroupApi.getGroupMember(msg.peerUin, await this.core.apis.UserApi.getUinByUidV2(msg.senderUid));
       resMsg.group_id = parseInt(ret.tmpChatInfo!.groupCode);
       resMsg.sender.nickname = member?.nick ?? member?.cardName ?? '临时会话';
       resMsg.temp_source = 0;

packages/napcat-onebot/config/config.ts

@@ -6,7 +6,7 @@ const HttpServerConfigSchema = Type.Object({
   port: Type.Number({ default: 3000 }),
   host: Type.String({ default: '127.0.0.1' }),
   enableCors: Type.Boolean({ default: true }),
-  enableWebsocket: Type.Boolean({ default: true }),
+  enableWebsocket: Type.Boolean({ default: false }),
   messagePostFormat: Type.String({ default: 'array' }),
   token: Type.String({ default: '' }),
   debug: Type.Boolean({ default: false }),
@@ -18,7 +18,7 @@ const HttpSseServerConfigSchema = Type.Object({
   port: Type.Number({ default: 3000 }),
   host: Type.String({ default: '127.0.0.1' }),
   enableCors: Type.Boolean({ default: true }),
-  enableWebsocket: Type.Boolean({ default: true }),
+  enableWebsocket: Type.Boolean({ default: false }),
   messagePostFormat: Type.String({ default: 'array' }),
   token: Type.String({ default: '' }),
   debug: Type.Boolean({ default: false }),

packages/napcat-onebot/event/notice/OB11GroupGrayTipEvent.ts

@@ -0,0 +1,35 @@
+import { OB11BaseNoticeEvent } from './OB11BaseNoticeEvent';
+import { NapCatCore } from 'napcat-core';
+
+/**
+ * 群灰条消息事件
+ * 用于上报未知类型的灰条消息，便于下游检测和处理伪造灰条攻击
+ */
+export class OB11GroupGrayTipEvent extends OB11BaseNoticeEvent {
+  notice_type = 'notify';
+  sub_type = 'gray_tip';
+  group_id: number;
+  user_id: number;        // 真实发送者QQ（如果是伪造的灰条，这就是攻击者）
+  message_id: number;     // 消息ID，可用于撤回
+  busi_id: string;        // 业务ID
+  content: string;        // 灰条内容（JSON字符串）
+  raw_info: unknown;      // 原始信息
+
+  constructor (
+    core: NapCatCore,
+    groupId: number,
+    userId: number,
+    messageId: number,
+    busiId: string,
+    content: string,
+    rawInfo: unknown
+  ) {
+    super(core);
+    this.group_id = groupId;
+    this.user_id = userId;
+    this.message_id = messageId;
+    this.busi_id = busiId;
+    this.content = content;
+    this.raw_info = rawInfo;
+  }
+}

packages/napcat-onebot/index.ts

@@ -49,10 +49,11 @@ import {
   OneBotConfigSchema,
 } from './config/config';
 import { OB11Message } from './types';
+import { existsSync } from 'node:fs';
 import { IOB11NetworkAdapter } from '@/napcat-onebot/network/adapter';
 import { OB11HttpSSEServerAdapter } from './network/http-server-sse';
 import { OB11PluginMangerAdapter } from './network/plugin-manger';
-import { existsSync } from 'node:fs';
+
 import { proxiedListenerOf } from '@/napcat-core/helper/proxy-handler';
 import { OneBotFileApi } from './api/file';
 
@@ -160,6 +161,7 @@ export class NapCatOneBot11Adapter {
     // this.networkManager.registerAdapter(
     //     new OB11PluginAdapter('myPlugin', this.core, this,this.actions)
     // );
+    // 检查插件目录是否存在，不存在则不加载插件管理器
     if (existsSync(this.context.pathWrapper.pluginPath)) {
       this.context.logger.log('[Plugins] 插件目录存在，开始加载插件');
       this.networkManager.registerAdapter(
@@ -246,7 +248,7 @@ export class NapCatOneBot11Adapter {
     await this.handleConfigChange(prev.network.websocketClients, now.network.websocketClients, OB11WebSocketClientAdapter);
   }
 
-  private async handleConfigChange<CT extends NetworkAdapterConfig>(
+  private async handleConfigChange<CT extends NetworkAdapterConfig> (
     prevConfig: NetworkAdapterConfig[],
     nowConfig: NetworkAdapterConfig[],
     adapterClass: new (
@@ -305,6 +307,9 @@ export class NapCatOneBot11Adapter {
     };
 
     msgListener.onRecvMsg = async (msg) => {
+      if (!this.networkManager.hasActiveAdapters()) {
+        return;
+      }
       for (const m of msg) {
         if (this.bootTime > parseInt(m.msgTime)) {
           this.context.logger.logDebug(`消息时间${m.msgTime}早于启动时间${this.bootTime}，忽略上报`);
@@ -384,6 +389,7 @@ export class NapCatOneBot11Adapter {
       }
     };
     msgListener.onKickedOffLine = async (kick) => {
+      WebUiDataRuntime.setQQLoginStatus(false);
       const event = new BotOfflineEvent(this.core, kick.tipsTitle, kick.tipsDesc);
       this.networkManager
         .emitEvent(event)
@@ -517,15 +523,14 @@ export class NapCatOneBot11Adapter {
   }
 
   private async emitMsg (message: RawMessage) {
-    const network = await this.networkManager.getAllConfig();
     this.context.logger.logDebug('收到新消息 RawMessage', message);
     await Promise.allSettled([
-      this.handleMsg(message, network),
+      this.handleMsg(message),
       message.chatType === ChatType.KCHATTYPEGROUP ? this.handleGroupEvent(message) : this.handlePrivateMsgEvent(message),
     ]);
   }
 
-  private async handleMsg (message: RawMessage, network: Array<NetworkAdapterConfig>) {
+  private async handleMsg (message: RawMessage) {
     // 过滤无效消息
     if (message.msgType === NTMsgType.KMSGTYPENULL) {
       return;
@@ -535,10 +540,36 @@ export class NapCatOneBot11Adapter {
       if (ob11Msg) {
         const isSelfMsg = this.isSelfMessage(ob11Msg);
         this.context.logger.logDebug('转化为 OB11Message', ob11Msg);
-        const msgMap = this.createMsgMap(network, ob11Msg, isSelfMsg, message);
-        this.handleDebugNetwork(network, msgMap, message);
-        this.handleNotReportSelfNetwork(network, msgMap, isSelfMsg);
-        this.networkManager.emitEventByNames(msgMap);
+        if (isSelfMsg || message.chatType !== ChatType.KCHATTYPEGROUP) {
+          const targetId = parseInt(message.peerUin);
+          ob11Msg.stringMsg.target_id = targetId;
+          ob11Msg.arrayMsg.target_id = targetId;
+        }
+
+        const msgMap = new Map<string, OB11Message>();
+
+        for (const adapter of this.networkManager.adapters.values()) {
+          if (!adapter.isActive) continue;
+          const config = adapter.config;
+          if (isSelfMsg) {
+            if (!('reportSelfMessage' in config) || !config.reportSelfMessage) {
+              continue;
+            }
+          }
+          const msgData = config.messagePostFormat === 'string' ? ob11Msg.stringMsg : ob11Msg.arrayMsg;
+          if (config.debug) {
+            const clone = structuredClone(msgData);
+            clone.raw = message;
+            msgMap.set(adapter.name, clone);
+          } else {
+            msgMap.set(adapter.name, msgData);
+          }
+        }
+        if (msgMap.size > 0) {
+          this.networkManager.emitEventByNames(msgMap);
+        } else if (this.networkManager.hasActiveAdapters()) {
+          this.context.logger.logDebug('没有可用的网络适配器发送消息，消息内容:', message);
+        }
       }
     } catch (e) {
       this.context.logger.logError('constructMessage error: ', e);
@@ -553,48 +584,6 @@ export class NapCatOneBot11Adapter {
       ob11Msg.arrayMsg.user_id.toString() === this.core.selfInfo.uin;
   }
 
-  private createMsgMap (network: Array<NetworkAdapterConfig>, ob11Msg: {
-    stringMsg: OB11Message;
-    arrayMsg: OB11Message;
-  }, isSelfMsg: boolean, message: RawMessage): Map<string, OB11Message> {
-    const msgMap: Map<string, OB11Message> = new Map();
-    network.filter(e => e.enable).forEach(e => {
-      if (isSelfMsg || message.chatType !== ChatType.KCHATTYPEGROUP) {
-        ob11Msg.stringMsg.target_id = parseInt(message.peerUin);
-        ob11Msg.arrayMsg.target_id = parseInt(message.peerUin);
-      }
-      if ('messagePostFormat' in e && e.messagePostFormat === 'string') {
-        msgMap.set(e.name, structuredClone(ob11Msg.stringMsg));
-      } else {
-        msgMap.set(e.name, structuredClone(ob11Msg.arrayMsg));
-      }
-    });
-    return msgMap;
-  }
-
-  private handleDebugNetwork (network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, message: RawMessage) {
-    const debugNetwork = network.filter(e => e.enable && e.debug);
-    if (debugNetwork.length > 0) {
-      debugNetwork.forEach(adapter => {
-        const msg = msgMap.get(adapter.name);
-        if (msg) {
-          msg.raw = message;
-        }
-      });
-    } else if (msgMap.size === 0) {
-      this.context.logger.logDebug('没有可用的网络适配器发送消息，消息内容:', message);
-    }
-  }
-
-  private handleNotReportSelfNetwork (network: Array<NetworkAdapterConfig>, msgMap: Map<string, OB11Message>, isSelfMsg: boolean) {
-    if (isSelfMsg) {
-      const notReportSelfNetwork = network.filter(e => e.enable && (('reportSelfMessage' in e && !e.reportSelfMessage) || !('reportSelfMessage' in e)));
-      notReportSelfNetwork.forEach(adapter => {
-        msgMap.delete(adapter.name);
-      });
-    }
-  }
-
   private async handleGroupEvent (message: RawMessage) {
     try {
       // 群名片修改事件解析 任何都该判断

packages/napcat-onebot/network/adapter.ts

@@ -23,11 +23,15 @@ export abstract class IOB11NetworkAdapter<CT extends NetworkAdapterConfig> {
     this.logger = core.context.logger;
   }
 
-  abstract onEvent<T extends OB11EmitEventContent>(event: T): Promise<void>;
+  abstract onEvent<T extends OB11EmitEventContent> (event: T): Promise<void>;
 
   abstract open (): void | Promise<void>;
 
   abstract close (): void | Promise<void>;
 
   abstract reload (config: unknown): OB11NetworkReloadType | Promise<OB11NetworkReloadType>;
+
+  get isActive (): boolean {
+    return this.isEnable;
+  }
 }

packages/napcat-onebot/network/http-server-sse.ts

@@ -5,6 +5,10 @@ import { OB11HttpServerAdapter } from './http-server';
 export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
   private sseClients: Response[] = [];
 
+  override get isActive (): boolean {
+    return this.isEnable && (this.sseClients.length > 0 || super.isActive);
+  }
+
   override async handleRequest (req: Request, res: Response) {
     if (req.path === '/_events') {
       this.createSseSupport(req, res);
@@ -25,7 +29,8 @@ export class OB11HttpSSEServerAdapter extends OB11HttpServerAdapter {
     });
   }
 
-  override async onEvent<T extends OB11EmitEventContent>(event: T) {
+  override async onEvent<T extends OB11EmitEventContent> (event: T) {
+    super.onEvent(event);
     const promises: Promise<void>[] = [];
     this.sseClients.forEach((res) => {
       promises.push(new Promise<void>((resolve, reject) => {

packages/napcat-onebot/network/http-server.ts

@@ -1,6 +1,6 @@
 import { OB11EmitEventContent, OB11NetworkReloadType } from './index';
 import express, { Express, NextFunction, Request, Response } from 'express';
-import http from 'http';
+import http, { IncomingMessage } from 'http';
 import { OB11Response } from '@/napcat-onebot/action/OneBotAction';
 import cors from 'cors';
 import { HttpServerConfig } from '@/napcat-onebot/config/config';
@@ -8,13 +8,41 @@ import { IOB11NetworkAdapter } from '@/napcat-onebot/network/adapter';
 import json5 from 'json5';
 import { isFinished } from 'on-finished';
 import typeis from 'type-is';
+import { WebSocket, WebSocketServer, RawData } from 'ws';
+import { URL } from 'url';
+import { ActionName } from '@/napcat-onebot/action/router';
+import { OB11HeartbeatEvent } from '@/napcat-onebot/event/meta/OB11HeartbeatEvent';
+import { OB11LifeCycleEvent, LifeCycleSubType } from '@/napcat-onebot/event/meta/OB11LifeCycleEvent';
+import { Mutex } from 'async-mutex';
 
 export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig> {
   private app: Express | undefined;
   private server: http.Server | undefined;
+  private wsServer?: WebSocketServer;
+  private wsClients: WebSocket[] = [];
+  private wsClientsMutex = new Mutex();
+  private heartbeatIntervalId: NodeJS.Timeout | null = null;
+  private wsClientWithEvent: WebSocket[] = [];
 
-  override async onEvent<T extends OB11EmitEventContent> (_event: T) {
+  override get isActive (): boolean {
+    return this.isEnable && this.wsClientWithEvent.length > 0;
+  }
+
+  override async onEvent<T extends OB11EmitEventContent> (event: T) {
     // http server is passive, no need to emit event
+    this.wsClientsMutex.runExclusive(async () => {
+      const promises = this.wsClientWithEvent.map((wsClient) => {
+        return new Promise<void>((resolve, reject) => {
+          if (wsClient.readyState === WebSocket.OPEN) {
+            wsClient.send(JSON.stringify(event));
+            resolve();
+          } else {
+            reject(new Error('WebSocket is not open'));
+          }
+        });
+      });
+      await Promise.allSettled(promises);
+    });
   }
 
   open () {
@@ -36,11 +64,24 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
     this.isEnable = false;
     this.server?.close();
     this.app = undefined;
+    this.stopHeartbeat();
+    await this.wsClientsMutex.runExclusive(async () => {
+      this.wsClients.forEach((wsClient) => {
+        wsClient.close();
+      });
+      this.wsClients = [];
+      this.wsClientWithEvent = [];
+    });
+    this.wsServer?.close();
   }
 
   private initializeServer () {
     this.app = express();
     this.server = http.createServer(this.app);
+    if (this.config.enableWebsocket) {
+      this.wsServer = new WebSocketServer({ server: this.server });
+      this.createWSServer(this.wsServer);
+    }
 
     this.app.use(cors());
     this.app.use(express.urlencoded({ extended: true, limit: '5000mb' }));
@@ -93,6 +134,137 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
     }
   }
 
+  createWSServer (newServer: WebSocketServer) {
+    newServer.on('connection', async (wsClient, wsReq) => {
+      if (!this.isEnable) {
+        wsClient.close();
+        return;
+      }
+      if (!this.authorizeWS(this.config.token, wsClient, wsReq)) {
+        return;
+      }
+      const paramUrl = wsReq.url?.indexOf('?') !== -1 ? wsReq.url?.substring(0, wsReq.url?.indexOf('?')) : wsReq.url;
+      const isApiConnect = paramUrl === '/api' || paramUrl === '/api/';
+      if (!isApiConnect) {
+        this.connectEvent(this.core, wsClient);
+      }
+
+      wsClient.on('error', (err) => this.logger.log('[OneBot] [HTTP WebSocket] Client Error:', err.message));
+      wsClient.on('message', (message) => {
+        this.handleWSMessage(wsClient, message).then().catch(e => this.logger.logError(e));
+      });
+      wsClient.on('ping', () => {
+        wsClient.pong();
+      });
+      wsClient.on('pong', () => {
+        // this.logger.logDebug('[OneBot] [HTTP WebSocket] Pong received');
+      });
+      wsClient.once('close', () => {
+        this.wsClientsMutex.runExclusive(async () => {
+          const NormolIndex = this.wsClients.indexOf(wsClient);
+          if (NormolIndex !== -1) {
+            this.wsClients.splice(NormolIndex, 1);
+          }
+          const EventIndex = this.wsClientWithEvent.indexOf(wsClient);
+          if (EventIndex !== -1) {
+            this.wsClientWithEvent.splice(EventIndex, 1);
+          }
+          if (this.wsClientWithEvent.length === 0) {
+            this.stopHeartbeat();
+          }
+        });
+      });
+      await this.wsClientsMutex.runExclusive(async () => {
+        if (!isApiConnect) {
+          this.wsClientWithEvent.push(wsClient);
+        }
+        this.wsClients.push(wsClient);
+        if (this.wsClientWithEvent.length > 0) {
+          this.startHeartbeat();
+        }
+      });
+    }).on('error', (err) => this.logger.log('[OneBot] [HTTP WebSocket] Server Error:', err.message));
+  }
+
+  connectEvent (core: any, wsClient: WebSocket) {
+    try {
+      this.checkStateAndReply<unknown>(new OB11LifeCycleEvent(core, LifeCycleSubType.CONNECT), wsClient).catch(e => this.logger.logError('[OneBot] [HTTP WebSocket] 发送生命周期失败', e));
+    } catch (e) {
+      this.logger.logError('[OneBot] [HTTP WebSocket] 发送生命周期失败', e);
+    }
+  }
+
+  private startHeartbeat () {
+    if (this.heartbeatIntervalId) return;
+    this.heartbeatIntervalId = setInterval(() => {
+      this.wsClientsMutex.runExclusive(async () => {
+        this.wsClientWithEvent.forEach((wsClient) => {
+          if (wsClient.readyState === WebSocket.OPEN) {
+            wsClient.send(JSON.stringify(new OB11HeartbeatEvent(this.core, 30000, this.core.selfInfo.online ?? true, true)));
+          }
+        });
+      });
+    }, 30000);
+  }
+
+  private stopHeartbeat () {
+    if (this.heartbeatIntervalId) {
+      clearInterval(this.heartbeatIntervalId);
+      this.heartbeatIntervalId = null;
+    }
+  }
+
+  private authorizeWS (token: string | undefined, wsClient: WebSocket, wsReq: IncomingMessage) {
+    if (!token || token.length === 0) return true;
+    const url = new URL(wsReq?.url || '', `http://${wsReq.headers.host}`);
+    const QueryClientToken = url.searchParams.get('access_token');
+    const HeaderClientToken = wsReq.headers.authorization?.split('Bearer ').pop() || '';
+    const ClientToken = typeof (QueryClientToken) === 'string' && QueryClientToken !== '' ? QueryClientToken : HeaderClientToken;
+    if (ClientToken === token) {
+      return true;
+    }
+    wsClient.send(JSON.stringify(OB11Response.res(null, 'failed', 1403, 'token验证失败')));
+    wsClient.close();
+    return false;
+  }
+
+  private async checkStateAndReply<T> (data: T, wsClient: WebSocket) {
+    return await new Promise<void>((resolve, reject) => {
+      if (wsClient.readyState === WebSocket.OPEN) {
+        wsClient.send(JSON.stringify(data));
+        resolve();
+      } else {
+        reject(new Error('WebSocket is not open'));
+      }
+    });
+  }
+
+  private async handleWSMessage (wsClient: WebSocket, message: RawData) {
+    let receiveData: { action: typeof ActionName[keyof typeof ActionName], params?: any, echo?: any; } = { action: ActionName.Unknown, params: {} };
+    let echo;
+    try {
+      receiveData = json5.parse(message.toString());
+      echo = receiveData.echo;
+    } catch {
+      await this.checkStateAndReply<unknown>(OB11Response.error('json解析失败,请检查数据格式', 1400, echo), wsClient);
+      return;
+    }
+    receiveData.params = (receiveData?.params) ? receiveData.params : {};
+
+    const action = this.actions.get(receiveData.action as any);
+    if (!action) {
+      this.logger.logError('[OneBot] [HTTP WebSocket] 发生错误', '不支持的API ' + receiveData.action);
+      await this.checkStateAndReply<unknown>(OB11Response.error('不支持的API ' + receiveData.action, 1404, echo), wsClient);
+      return;
+    }
+    const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config, {
+      send: async (data: object) => {
+        await this.checkStateAndReply<unknown>({ ...OB11Response.ok(data, echo ?? '', true) }, wsClient);
+      },
+    });
+    await this.checkStateAndReply<unknown>({ ...retdata }, wsClient);
+  }
+
   async httpApiRequest (req: Request, res: Response, request_sse: boolean = false) {
     let payload = req.body;
     if (req.method === 'get') {
@@ -152,6 +324,7 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
   async reload (newConfig: HttpServerConfig) {
     const wasEnabled = this.isEnable;
     const oldPort = this.config.port;
+    const oldEnableWebsocket = this.config.enableWebsocket;
     this.config = newConfig;
 
     if (newConfig.enable && !wasEnabled) {
@@ -162,7 +335,7 @@ export class OB11HttpServerAdapter extends IOB11NetworkAdapter<HttpServerConfig>
       return OB11NetworkReloadType.NetWorkClose;
     }
 
-    if (oldPort !== newConfig.port) {
+    if (oldPort !== newConfig.port || oldEnableWebsocket !== newConfig.enableWebsocket) {
       this.close();
       if (newConfig.enable) {
         this.open();

packages/napcat-onebot/network/index.ts

@@ -21,7 +21,7 @@ export class OB11NetworkManager {
 
   async emitEvent (event: OB11EmitEventContent) {
     return Promise.all(Array.from(this.adapters.values()).map(async adapter => {
-      if (adapter.isEnable) {
+      if (adapter.isActive) {
         return await adapter.onEvent(event);
       }
     }));
@@ -34,7 +34,7 @@ export class OB11NetworkManager {
   async emitEventByName (names: string[], event: OB11EmitEventContent) {
     return Promise.all(names.map(async name => {
       const adapter = this.adapters.get(name);
-      if (adapter && adapter.isEnable) {
+      if (adapter && adapter.isActive) {
         return await adapter.onEvent(event);
       }
     }));
@@ -43,29 +43,29 @@ export class OB11NetworkManager {
   async emitEventByNames (map: Map<string, OB11EmitEventContent>) {
     return Promise.all(Array.from(map.entries()).map(async ([name, event]) => {
       const adapter = this.adapters.get(name);
-      if (adapter && adapter.isEnable) {
+      if (adapter && adapter.isActive) {
         return await adapter.onEvent(event);
       }
     }));
   }
 
-  registerAdapter<CT extends NetworkAdapterConfig>(adapter: IOB11NetworkAdapter<CT>) {
+  registerAdapter<CT extends NetworkAdapterConfig> (adapter: IOB11NetworkAdapter<CT>) {
     this.adapters.set(adapter.name, adapter);
   }
 
-  async registerAdapterAndOpen<CT extends NetworkAdapterConfig>(adapter: IOB11NetworkAdapter<CT>) {
+  async registerAdapterAndOpen<CT extends NetworkAdapterConfig> (adapter: IOB11NetworkAdapter<CT>) {
     this.registerAdapter(adapter);
     await adapter.open();
   }
 
-  async closeSomeAdapters<CT extends NetworkAdapterConfig>(adaptersToClose: IOB11NetworkAdapter<CT>[]) {
+  async closeSomeAdapters<CT extends NetworkAdapterConfig> (adaptersToClose: IOB11NetworkAdapter<CT>[]) {
     for (const adapter of adaptersToClose) {
       this.adapters.delete(adapter.name);
       await adapter.close();
     }
   }
 
-  async closeSomeAdaterWhenOpen<CT extends NetworkAdapterConfig>(adaptersToClose: IOB11NetworkAdapter<CT>[]) {
+  async closeSomeAdaterWhenOpen<CT extends NetworkAdapterConfig> (adaptersToClose: IOB11NetworkAdapter<CT>[]) {
     for (const adapter of adaptersToClose) {
       this.adapters.delete(adapter.name);
       if (adapter.isEnable) {
@@ -88,17 +88,21 @@ export class OB11NetworkManager {
     this.adapters.clear();
   }
 
-  async readloadAdapter<T>(name: string, config: T) {
+  async readloadAdapter<T> (name: string, config: T) {
     const adapter = this.adapters.get(name);
     if (adapter) {
       await adapter.reload(config);
     }
   }
 
-  async readloadSomeAdapters<T>(configMap: Map<string, T>) {
+  async readloadSomeAdapters<T> (configMap: Map<string, T>) {
     await Promise.all(Array.from(configMap.entries()).map(([name, config]) => this.readloadAdapter(name, config)));
   }
 
+  hasActiveAdapters (): boolean {
+    return Array.from(this.adapters.values()).some(adapter => adapter.isActive);
+  }
+
   async getAllConfig () {
     return Array.from(this.adapters.values()).map(adapter => adapter.config);
   }

packages/napcat-onebot/network/plugin-manger.ts

@@ -1,9 +1,9 @@
-import { OB11EmitEventContent, OB11NetworkReloadType } from './index';
-import { NapCatOneBot11Adapter, OB11Message } from '@/napcat-onebot/index';
-import { NapCatCore } from 'napcat-core';
-import { PluginConfig } from '../config/config';
 import { ActionMap } from '../action';
+import { NapCatCore } from 'napcat-core';
+import { NapCatOneBot11Adapter, OB11Message } from '@/napcat-onebot/index';
+import { OB11EmitEventContent, OB11NetworkReloadType } from './index';
 import { IOB11NetworkAdapter } from '@/napcat-onebot/network/adapter';
+import { PluginConfig } from '../config/config';
 import fs from 'fs';
 import path from 'path';
 
@@ -11,13 +11,39 @@ export interface PluginPackageJson {
   name?: string;
   version?: string;
   main?: string;
+  description?: string;
+  author?: string;
 }
 
 export interface PluginModule<T extends OB11EmitEventContent = OB11EmitEventContent> {
-  plugin_init: (core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap, instance: OB11PluginMangerAdapter) => void | Promise<void>;
-  plugin_onmessage?: (adapter: string, core: NapCatCore, obCtx: NapCatOneBot11Adapter, event: OB11Message, actions: ActionMap, instance: OB11PluginMangerAdapter) => void | Promise<void>;
-  plugin_onevent?: (adapter: string, core: NapCatCore, obCtx: NapCatOneBot11Adapter, event: T, actions: ActionMap, instance: OB11PluginMangerAdapter) => void | Promise<void>;
-  plugin_cleanup?: (core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap, instance: OB11PluginMangerAdapter) => void | Promise<void>;
+  plugin_init: (
+    core: NapCatCore,
+    obContext: NapCatOneBot11Adapter,
+    actions: ActionMap,
+    instance: OB11PluginMangerAdapter
+  ) => void | Promise<void>;
+  plugin_onmessage?: (
+    adapter: string,
+    core: NapCatCore,
+    obCtx: NapCatOneBot11Adapter,
+    event: OB11Message,
+    actions: ActionMap,
+    instance: OB11PluginMangerAdapter
+  ) => void | Promise<void>;
+  plugin_onevent?: (
+    adapter: string,
+    core: NapCatCore,
+    obCtx: NapCatOneBot11Adapter,
+    event: T,
+    actions: ActionMap,
+    instance: OB11PluginMangerAdapter
+  ) => void | Promise<void>;
+  plugin_cleanup?: (
+    core: NapCatCore,
+    obContext: NapCatOneBot11Adapter,
+    actions: ActionMap,
+    instance: OB11PluginMangerAdapter
+  ) => void | Promise<void>;
 }
 
 export interface LoadedPlugin {
@@ -29,12 +55,25 @@ export interface LoadedPlugin {
   module: PluginModule;
 }
 
+export interface PluginStatusConfig {
+  [key: string]: boolean; // key: pluginName, value: enabled
+}
+
 export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
   private readonly pluginPath: string;
+  private readonly configPath: string;
   private loadedPlugins: Map<string, LoadedPlugin> = new Map();
   declare config: PluginConfig;
+
+  override get isActive (): boolean {
+    return this.isEnable && this.loadedPlugins.size > 0;
+  }
+
   constructor (
-    name: string, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap
+    name: string,
+    core: NapCatCore,
+    obContext: NapCatOneBot11Adapter,
+    actions: ActionMap
   ) {
     const config = {
       name,
@@ -45,24 +84,60 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
     };
     super(name, config, core, obContext, actions);
     this.pluginPath = this.core.context.pathWrapper.pluginPath;
+    this.configPath = path.join(this.core.context.pathWrapper.configPath, 'plugins.json');
+  }
+
+  private loadPluginConfig (): PluginStatusConfig {
+    if (fs.existsSync(this.configPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(this.configPath, 'utf-8'));
+      } catch (e) {
+        this.logger.logWarn('[Plugin Adapter] Error parsing plugins.json', e);
+      }
+    }
+    return {};
+  }
+
+  private savePluginConfig (config: PluginStatusConfig) {
+    try {
+      fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    } catch (e) {
+      this.logger.logError('[Plugin Adapter] Error saving plugins.json', e);
+    }
   }
 
   /**
-     * 扫描并加载插件
-     */
+   * 扫描并加载插件
+   */
   private async loadPlugins (): Promise<void> {
     try {
       // 确保插件目录存在
       if (!fs.existsSync(this.pluginPath)) {
-        this.logger.logWarn(`[Plugin Adapter] Plugin directory does not exist: ${this.pluginPath}`);
+        this.logger.logWarn(
+          `[Plugin Adapter] Plugin directory does not exist: ${this.pluginPath}`
+        );
         fs.mkdirSync(this.pluginPath, { recursive: true });
         return;
       }
 
       const items = fs.readdirSync(this.pluginPath, { withFileTypes: true });
+      const pluginConfig = this.loadPluginConfig();
 
       // 扫描文件和目录
       for (const item of items) {
+        let pluginName = '';
+        if (item.isFile()) {
+          pluginName = path.parse(item.name).name;
+        } else if (item.isDirectory()) {
+          pluginName = item.name;
+        }
+
+        // Check if plugin is disabled in config
+        if (pluginConfig[pluginName] === false) {
+          this.logger.log(`[Plugin Adapter] Plugin ${pluginName} is disabled in config, skipping`);
+          continue;
+        }
+
         if (item.isFile()) {
           // 处理单文件插件
           await this.loadFilePlugin(item.name);
@@ -72,16 +147,18 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
         }
       }
 
-      this.logger.log(`[Plugin Adapter] Loaded ${this.loadedPlugins.size} plugins`);
+      this.logger.log(
+        `[Plugin Adapter] Loaded ${this.loadedPlugins.size} plugins`
+      );
     } catch (error) {
       this.logger.logError('[Plugin Adapter] Error loading plugins:', error);
     }
   }
 
   /**
-     * 加载单文件插件 (.mjs, .js)
-     */
-  private async loadFilePlugin (filename: string): Promise<void> {
+   * 加载单文件插件 (.mjs, .js)
+   */
+  public async loadFilePlugin (filename: string): Promise<void> {
     // 只处理支持的文件类型
     if (!this.isSupportedFile(filename)) {
       return;
@@ -89,11 +166,20 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
 
     const filePath = path.join(this.pluginPath, filename);
     const pluginName = path.parse(filename).name;
+    const pluginConfig = this.loadPluginConfig();
+
+    // Check if plugin is disabled in config
+    if (pluginConfig[pluginName] === false) {
+      this.logger.log(`[Plugin Adapter] Plugin ${pluginName} is disabled by user`);
+      return;
+    }
 
     try {
       const module = await this.importModule(filePath);
       if (!this.isValidPluginModule(module)) {
-        this.logger.logWarn(`[Plugin Adapter] File ${filename} is not a valid plugin (missing plugin methods)`);
+        this.logger.logWarn(
+          `[Plugin Adapter] File ${filename} is not a valid plugin (missing plugin methods)`
+        );
         return;
       }
 
@@ -106,15 +192,31 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
 
       await this.registerPlugin(plugin);
     } catch (error) {
-      this.logger.logError(`[Plugin Adapter] Error loading file plugin ${filename}:`, error);
+      this.logger.logError(
+        `[Plugin Adapter] Error loading file plugin ${filename}:`,
+        error
+      );
     }
   }
 
   /**
-     * 加载目录插件
-     */
-  private async loadDirectoryPlugin (dirname: string): Promise<void> {
+   * 加载目录插件
+   */
+  public async loadDirectoryPlugin (dirname: string): Promise<void> {
     const pluginDir = path.join(this.pluginPath, dirname);
+    const pluginConfig = this.loadPluginConfig();
+
+    // Ideally we'd get the name from package.json first, but we can use dirname as a fallback identifier initially.
+    // However, the list scan uses item.name (dirname) as the key. Let's stick to using dirname/filename as the config key for simplicity and consistency.
+    // Wait, package.json name might override. But for management, consistent ID is better.
+    // Let's check config after parsing package.json?
+    // User expects to disable 'plugin-name'. But if multiple folders have same name? Not handled.
+    // Let's use dirname as the key for config to be consistent with file system.
+
+    if (pluginConfig[dirname] === false) {
+      this.logger.log(`[Plugin Adapter] Plugin ${dirname} is disabled by user`);
+      return;
+    }
 
     try {
       // 尝试读取 package.json
@@ -126,14 +228,22 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
           const packageContent = fs.readFileSync(packageJsonPath, 'utf-8');
           packageJson = JSON.parse(packageContent);
         } catch (error) {
-          this.logger.logWarn(`[Plugin Adapter] Invalid package.json in ${dirname}:`, error);
+          this.logger.logWarn(
+            `[Plugin Adapter] Invalid package.json in ${dirname}:`,
+            error
+          );
         }
       }
 
+      // Check if disabled by package name IF package.json exists?
+      // No, file system name is more reliable ID for resource management here.
+
       // 确定入口文件
       const entryFile = this.findEntryFile(pluginDir, packageJson);
       if (!entryFile) {
-        this.logger.logWarn(`[Plugin Adapter] No valid entry file found for plugin directory: ${dirname}`);
+        this.logger.logWarn(
+          `[Plugin Adapter] No valid entry file found for plugin directory: ${dirname}`
+        );
         return;
       }
 
@@ -141,7 +251,9 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
       const module = await this.importModule(entryPath);
 
       if (!this.isValidPluginModule(module)) {
-        this.logger.logWarn(`[Plugin Adapter] Directory ${dirname} does not contain a valid plugin`);
+        this.logger.logWarn(
+          `[Plugin Adapter] Directory ${dirname} does not contain a valid plugin`
+        );
         return;
       }
 
@@ -156,14 +268,20 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
 
       await this.registerPlugin(plugin);
     } catch (error) {
-      this.logger.logError(`[Plugin Adapter] Error loading directory plugin ${dirname}:`, error);
+      this.logger.logError(
+        `[Plugin Adapter] Error loading directory plugin ${dirname}:`,
+        error
+      );
     }
   }
 
   /**
-     * 查找插件目录的入口文件
-     */
-  private findEntryFile (pluginDir: string, packageJson?: PluginPackageJson): string | null {
+   * 查找插件目录的入口文件
+   */
+  private findEntryFile (
+    pluginDir: string,
+    packageJson?: PluginPackageJson
+  ): string | null {
     // 优先级：package.json main > 默认文件名
     const possibleEntries = [
       packageJson?.main,
@@ -184,53 +302,69 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
   }
 
   /**
-     * 检查是否为支持的文件类型
-     */
+   * 检查是否为支持的文件类型
+   */
   private isSupportedFile (filename: string): boolean {
     const ext = path.extname(filename).toLowerCase();
     return ['.mjs', '.js'].includes(ext);
   }
 
   /**
-     * 动态导入模块
-     */
+   * 动态导入模块
+   */
   private async importModule (filePath: string): Promise<any> {
     const fileUrl = `file://${filePath.replace(/\\/g, '/')}`;
-    return await import(fileUrl);
+    // Add timestamp to force reload cache if supported or just import
+    // Note: dynamic import caching is tricky in ESM. Adding query param might help?
+    const fileUrlWithQuery = `${fileUrl}?t=${Date.now()}`;
+    return await import(fileUrlWithQuery);
   }
 
   /**
-     * 检查模块是否为有效的插件模块
-     */
+   * 检查模块是否为有效的插件模块
+   */
   private isValidPluginModule (module: any): module is PluginModule {
     return module && typeof module.plugin_init === 'function';
   }
 
   /**
-     * 注册插件
-     */
+   * 注册插件
+   */
   private async registerPlugin (plugin: LoadedPlugin): Promise<void> {
     // 检查名称冲突
     if (this.loadedPlugins.has(plugin.name)) {
-      this.logger.logWarn(`[Plugin Adapter] Plugin name conflict: ${plugin.name}, skipping...`);
+      this.logger.logWarn(
+        `[Plugin Adapter] Plugin name conflict: ${plugin.name}, skipping...`
+      );
       return;
     }
 
     this.loadedPlugins.set(plugin.name, plugin);
-    this.logger.log(`[Plugin Adapter] Registered plugin: ${plugin.name}${plugin.version ? ` v${plugin.version}` : ''}`);
+    this.logger.log(
+      `[Plugin Adapter] Registered plugin: ${plugin.name}${plugin.version ? ` v${plugin.version}` : ''
+      }`
+    );
 
     // 调用插件初始化方法（必须存在）
     try {
-      await plugin.module.plugin_init(this.core, this.obContext, this.actions, this);
+      await plugin.module.plugin_init(
+        this.core,
+        this.obContext,
+        this.actions,
+        this
+      );
       this.logger.log(`[Plugin Adapter] Initialized plugin: ${plugin.name}`);
     } catch (error) {
-      this.logger.logError(`[Plugin Adapter] Error initializing plugin ${plugin.name}:`, error);
+      this.logger.logError(
+        `[Plugin Adapter] Error initializing plugin ${plugin.name}:`,
+        error
+      );
     }
   }
 
   /**
-     * 卸载插件
-     */
+   * 卸载插件
+   */
   private async unloadPlugin (pluginName: string): Promise<void> {
     const plugin = this.loadedPlugins.get(pluginName);
     if (!plugin) {
@@ -240,10 +374,18 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
     // 调用插件清理方法
     if (typeof plugin.module.plugin_cleanup === 'function') {
       try {
-        await plugin.module.plugin_cleanup(this.core, this.obContext, this.actions, this);
+        await plugin.module.plugin_cleanup(
+          this.core,
+          this.obContext,
+          this.actions,
+          this
+        );
         this.logger.log(`[Plugin Adapter] Cleaned up plugin: ${pluginName}`);
       } catch (error) {
-        this.logger.logError(`[Plugin Adapter] Error cleaning up plugin ${pluginName}:`, error);
+        this.logger.logError(
+          `[Plugin Adapter] Error cleaning up plugin ${pluginName}:`,
+          error
+        );
       }
     }
 
@@ -251,7 +393,70 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
     this.logger.log(`[Plugin Adapter] Unloaded plugin: ${pluginName}`);
   }
 
-  async onEvent<T extends OB11EmitEventContent>(event: T) {
+  public async unregisterPlugin (pluginName: string): Promise<void> {
+    return this.unloadPlugin(pluginName);
+  }
+
+  public getPluginPath (): string {
+    return this.pluginPath;
+  }
+
+  public getPluginConfig (): PluginStatusConfig {
+    return this.loadPluginConfig();
+  }
+
+  public setPluginStatus (pluginName: string, enable: boolean): void {
+    const config = this.loadPluginConfig();
+    config[pluginName] = enable;
+    this.savePluginConfig(config);
+
+    // If disabling, unload immediately if loaded
+    if (!enable) {
+      // Note: pluginName passed here might be the package name or the filename/dirname
+      // But our registerPlugin uses plugin.name which comes from package.json or dirname.
+      // This mismatch is tricky. 
+      // Ideally, we should use a consistent ID. 
+      // Let's assume pluginName passed here effectively matches the ID used in loadedPlugins.
+      // But wait, loadDirectoryPlugin logic: name = packageJson.name || dirname.
+      // config key = dirname.
+      // If packageJson.name != dirname, we have a problem.
+      // To fix this properly: 
+      // 1. We need to know which LoadedPlugin corresponds to the enabled/disabled item.
+      // 2. Or we iterate loadedPlugins and find match.
+
+      for (const [_, loaded] of this.loadedPlugins.entries()) {
+        const dirOrFile = path.basename(loaded.pluginPath === this.pluginPath ? loaded.entryPath : loaded.pluginPath);
+        const ext = path.extname(dirOrFile);
+        const simpleName = ext ? path.parse(dirOrFile).name : dirOrFile; // filename without ext
+
+        // But wait, config key is the FILENAME (with ext for files?). 
+        // In Scan loop: 
+        // pluginName = path.parse(item.name).name (for file)
+        // pluginName = item.name (for dir)
+        // config[pluginName] check.
+
+        // So if file is "test.js", pluginName is "test". Config key "test".
+        // If dir is "test-plugin", pluginName is "test-plugin". Config key "test-plugin".
+
+        // loadedPlugin.name might be distinct.
+        // So we need to match loadedPlugin back to its fs source to unload it?
+
+        // loadedPlugin.entryPath or pluginPath helps.
+        // If it's a file plugin: loaded.entryPath ends with pluginName + ext.
+        // If it's a dir plugin: loaded.pluginPath ends with pluginName.
+
+        if (pluginName === simpleName) {
+          this.unloadPlugin(loaded.name).catch(e => this.logger.logError('Error unloading', e));
+        }
+      }
+    }
+    // If enabling, we need to load it. 
+    // But we can just rely on the API handler to call loadFile/DirectoryPlugin which now checks config.
+    // Wait, if I call loadFilePlugin("test.js") and config says enable=true, it loads.
+    // API handler needs to change to pass filename/dirname.
+  }
+
+  async onEvent<T extends OB11EmitEventContent> (event: T) {
     if (!this.isEnable) {
       return;
     }
@@ -269,21 +474,44 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
   }
 
   /**
-     * 调用插件的事件处理方法
-     */
-  private async callPluginEventHandler (plugin: LoadedPlugin, event: OB11EmitEventContent): Promise<void> {
+   * 调用插件的事件处理方法
+   */
+  private async callPluginEventHandler (
+    plugin: LoadedPlugin,
+    event: OB11EmitEventContent
+  ): Promise<void> {
     try {
       // 优先使用 plugin_onevent 方法
       if (typeof plugin.module.plugin_onevent === 'function') {
-        await plugin.module.plugin_onevent(this.name, this.core, this.obContext, event, this.actions, this);
+        await plugin.module.plugin_onevent(
+          this.name,
+          this.core,
+          this.obContext,
+          event,
+          this.actions,
+          this
+        );
       }
 
       // 如果是消息事件并且插件有 plugin_onmessage 方法，也调用
-      if ((event as any).message_type && typeof plugin.module.plugin_onmessage === 'function') {
-        await plugin.module.plugin_onmessage(this.name, this.core, this.obContext, event as OB11Message, this.actions, this);
+      if (
+        (event as any).message_type &&
+        typeof plugin.module.plugin_onmessage === 'function'
+      ) {
+        await plugin.module.plugin_onmessage(
+          this.name,
+          this.core,
+          this.obContext,
+          event as OB11Message,
+          this.actions,
+          this
+        );
       }
     } catch (error) {
-      this.logger.logError(`[Plugin Adapter] Error calling plugin ${plugin.name} event handler:`, error);
+      this.logger.logError(
+        `[Plugin Adapter] Error calling plugin ${plugin.name} event handler:`,
+        error
+      );
     }
   }
 
@@ -298,7 +526,9 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
     // 加载所有插件
     await this.loadPlugins();
 
-    this.logger.log(`[Plugin Adapter] Plugin adapter opened with ${this.loadedPlugins.size} plugins loaded`);
+    this.logger.log(
+      `[Plugin Adapter] Plugin adapter opened with ${this.loadedPlugins.size} plugins loaded`
+    );
   }
 
   async close () {
@@ -330,22 +560,22 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
   }
 
   /**
-     * 获取已加载的插件列表
-     */
+   * 获取已加载的插件列表
+   */
   public getLoadedPlugins (): LoadedPlugin[] {
     return Array.from(this.loadedPlugins.values());
   }
 
   /**
-     * 获取插件信息
-     */
+   * 获取插件信息
+   */
   public getPluginInfo (pluginName: string): LoadedPlugin | undefined {
     return this.loadedPlugins.get(pluginName);
   }
 
   /**
-     * 重载指定插件
-     */
+   * 重载指定插件
+   */
   public async reloadPlugin (pluginName: string): Promise<boolean> {
     const plugin = this.loadedPlugins.get(pluginName);
     if (!plugin) {
@@ -358,8 +588,10 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
       await this.unloadPlugin(pluginName);
 
       // 重新加载插件
-      const isDirectory = fs.statSync(plugin.pluginPath).isDirectory() &&
-                plugin.pluginPath !== this.pluginPath;
+      // Use logic to re-determine if it is directory or file based on original paths
+      // Note: we can't fully trust fs status if it's gone.
+      const isDirectory =
+        plugin.pluginPath !== this.pluginPath; // Simple check: if path is nested, it's a dir plugin
 
       if (isDirectory) {
         const dirname = path.basename(plugin.pluginPath);
@@ -369,10 +601,15 @@ export class OB11PluginMangerAdapter extends IOB11NetworkAdapter<PluginConfig> {
         await this.loadFilePlugin(filename);
       }
 
-      this.logger.log(`[Plugin Adapter] Plugin ${pluginName} reloaded successfully`);
+      this.logger.log(
+        `[Plugin Adapter] Plugin ${pluginName} reloaded successfully`
+      );
       return true;
     } catch (error) {
-      this.logger.logError(`[Plugin Adapter] Error reloading plugin ${pluginName}:`, error);
+      this.logger.logError(
+        `[Plugin Adapter] Error reloading plugin ${pluginName}:`,
+        error
+      );
       return false;
     }
   }

packages/napcat-onebot/network/plugin.ts

@@ -33,6 +33,10 @@ export class OB11PluginAdapter extends IOB11NetworkAdapter<PluginConfig> {
   private readonly pluginPath: string;
   private loadedPlugins: Map<string, LoadedPlugin> = new Map();
   declare config: PluginConfig;
+  override get isActive (): boolean {
+    return this.isEnable && this.loadedPlugins.size > 0;
+  }
+
   constructor (
     name: string, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap
   ) {

packages/napcat-onebot/network/websocket-client.ts

@@ -13,6 +13,10 @@ export class OB11WebSocketClientAdapter extends IOB11NetworkAdapter<WebsocketCli
   private connection: WebSocket | null = null;
   private heartbeatRef: NodeJS.Timeout | null = null;
 
+  override get isActive (): boolean {
+    return this.isEnable && !!this.connection && this.connection.readyState === WebSocket.OPEN;
+  }
+
   async onEvent<T extends OB11EmitEventContent> (event: T) {
     if (this.connection && this.connection.readyState === WebSocket.OPEN) {
       this.connection.send(JSON.stringify(event));

packages/napcat-onebot/network/websocket-server.ts

@@ -21,6 +21,10 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
   private heartbeatIntervalId: NodeJS.Timeout | null = null;
   wsClientWithEvent: WebSocket[] = [];
 
+  override get isActive (): boolean {
+    return this.isEnable && this.wsClientWithEvent.length > 0;
+  }
+
   constructor (
     name: string, config: WebsocketServerConfig, core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap
   ) {
@@ -70,6 +74,9 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
           if (EventIndex !== -1) {
             this.wsClientWithEvent.splice(EventIndex, 1);
           }
+          if (this.wsClientWithEvent.length === 0) {
+            this.stopHeartbeat();
+          }
         });
       });
       await this.wsClientsMutex.runExclusive(async () => {
@@ -77,6 +84,9 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
           this.wsClientWithEvent.push(wsClient);
         }
         this.wsClients.push(wsClient);
+        if (this.wsClientWithEvent.length > 0) {
+          this.startHeartbeat();
+        }
       });
     }).on('error', (err) => this.logger.log('[OneBot] [WebSocket Server] Server Error:', err.message));
   }
@@ -114,9 +124,6 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
     this.logger.log('[OneBot] [WebSocket Server] Server Started', typeof (addressInfo) === 'string' ? addressInfo : addressInfo?.address + ':' + addressInfo?.port);
 
     this.isEnable = true;
-    if (this.config.heartInterval > 0) {
-      this.registerHeartBeat();
-    }
   }
 
   async close () {
@@ -128,10 +135,7 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
         this.logger.log('[OneBot] [WebSocket Server] Server Closed');
       }
     });
-    if (this.heartbeatIntervalId) {
-      clearInterval(this.heartbeatIntervalId);
-      this.heartbeatIntervalId = null;
-    }
+    this.stopHeartbeat();
     await this.wsClientsMutex.runExclusive(async () => {
       this.wsClients.forEach((wsClient) => {
         wsClient.close();
@@ -141,7 +145,8 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
     });
   }
 
-  private registerHeartBeat () {
+  private startHeartbeat () {
+    if (this.heartbeatIntervalId || this.config.heartInterval <= 0) return;
     this.heartbeatIntervalId = setInterval(() => {
       this.wsClientsMutex.runExclusive(async () => {
         this.wsClientWithEvent.forEach((wsClient) => {
@@ -153,6 +158,13 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
     }, this.config.heartInterval);
   }
 
+  private stopHeartbeat () {
+    if (this.heartbeatIntervalId) {
+      clearInterval(this.heartbeatIntervalId);
+      this.heartbeatIntervalId = null;
+    }
+  }
+
   private authorize (token: string | undefined, wsClient: WebSocket, wsReq: IncomingMessage) {
     if (!token || token.length === 0) return true;// 客户端未设置密钥
     const url = new URL(wsReq?.url || '', `http://${wsReq.headers.host}`);
@@ -235,12 +247,9 @@ export class OB11WebSocketServerAdapter extends IOB11NetworkAdapter<WebsocketSer
     }
 
     if (oldHeartbeatInterval !== newConfig.heartInterval) {
-      if (this.heartbeatIntervalId) {
-        clearInterval(this.heartbeatIntervalId);
-        this.heartbeatIntervalId = null;
-      }
-      if (newConfig.heartInterval > 0 && this.isEnable) {
-        this.registerHeartBeat();
+      this.stopHeartbeat();
+      if (newConfig.heartInterval > 0 && this.isEnable && this.wsClientWithEvent.length > 0) {
+        this.startHeartbeat();
       }
       return OB11NetworkReloadType.NetWorkReload;
     }

packages/napcat-onebot/types/message.ts

@@ -31,6 +31,7 @@ export interface OB11Message {
   font: number;
   post_type?: EventType;
   raw?: RawMessage;
+  emoji_likes_list?: Array<{ emoji_id: string; emoji_type: string; likes_cnt: string; }>;// 仅get_msg生效
 }
 
 // 合并转发消息接口定义
@@ -46,7 +47,7 @@ export interface OB11Return<DataType> {
   message: string;
   echo?: unknown; // ws调用api才有此字段
   wording?: string;  // go-cqhttp字段，错误信息
-  stream?: 'stream-action' | 'normal-action' ; // 流式返回标记
+  stream?: 'stream-action' | 'normal-action'; // 流式返回标记
 }
 
 // 消息数据类型枚举
@@ -186,7 +187,7 @@ export interface OB11MessageNode {
     name?: string; // compatible with go-cqhttp
     content: OB11MessageMixType;
     source?: string;
-    news?: { text: string }[];
+    news?: { text: string; }[];
     summary?: string;
     prompt?: string;
     time?: string;
@@ -210,13 +211,13 @@ export interface OB11MessageIdMusic {
 // 自定义音乐消息接口定义
 export interface OB11MessageCustomMusic {
   type: OB11MessageDataType.music;
-  data: Omit<CustomMusicSignPostData, 'singer'> & { content?: string };
+  data: Omit<CustomMusicSignPostData, 'singer'> & { content?: string; };
 }
 
 // JSON消息接口定义
 export interface OB11MessageJson {
   type: OB11MessageDataType.json;
-  data: { config?: { token: string }, data: string | object };
+  data: { config?: { token: string; }, data: string | object; };
 }
 
 // 骰子消息接口定义
@@ -254,12 +255,12 @@ export interface OB11MessageForward {
 
 // 消息数据类型定义
 export type OB11MessageData =
-    OB11MessageText |
-    OB11MessageFace | OB11MessageMFace |
-    OB11MessageAt | OB11MessageReply |
-    OB11MessageImage | OB11MessageRecord | OB11MessageFile | OB11MessageVideo |
-    OB11MessageNode | OB11MessageIdMusic | OB11MessageCustomMusic | OB11MessageJson |
-    OB11MessageDice | OB11MessageRPS | OB11MessageMarkdown | OB11MessageForward | OB11MessageContext | OB11MessagePoke;
+  OB11MessageText |
+  OB11MessageFace | OB11MessageMFace |
+  OB11MessageAt | OB11MessageReply |
+  OB11MessageImage | OB11MessageRecord | OB11MessageFile | OB11MessageVideo |
+  OB11MessageNode | OB11MessageIdMusic | OB11MessageCustomMusic | OB11MessageJson |
+  OB11MessageDice | OB11MessageRPS | OB11MessageMarkdown | OB11MessageForward | OB11MessageContext | OB11MessagePoke;
 
 // 发送消息接口定义
 export interface OB11PostSendMsg {
@@ -270,7 +271,7 @@ export interface OB11PostSendMsg {
   messages?: OB11MessageMixType;
   auto_escape?: boolean | string;
   source?: string;
-  news?: { text: string }[];
+  news?: { text: string; }[];
   summary?: string;
   prompt?: string;
   time?: string;

packages/napcat-plugin-builtin/index.ts

@@ -0,0 +1,84 @@
+import type { ActionMap } from 'napcat-onebot/action';
+import { EventType } from 'napcat-onebot/event/OneBotEvent';
+import type { PluginModule } from 'napcat-onebot/network/plugin';
+import type { OB11Message, OB11PostSendMsg } from 'napcat-onebot/types/message';
+
+let actions: ActionMap | undefined = undefined;
+
+/**
+ * 插件初始化
+ */
+const plugin_init: PluginModule['plugin_init'] = async (_core, _obContext, _actions, _instance) => {
+  console.log('[Plugin: builtin] NapCat 内置插件已初始化');
+  actions = _actions;
+};
+
+/**
+ * 消息处理
+ * 当收到包含 #napcat 的消息时，回复版本信息
+ */
+const plugin_onmessage: PluginModule['plugin_onmessage'] = async (adapter, _core, _obCtx, event, _actions, instance) => {
+  if (event.post_type !== EventType.MESSAGE || !event.raw_message.startsWith('#napcat')) {
+    return;
+  }
+
+  try {
+    const versionInfo = await getVersionInfo(adapter, instance.config);
+    if (!versionInfo) return;
+
+    const message = formatVersionMessage(versionInfo);
+    await sendMessage(event, message, adapter, instance.config);
+
+    console.log('[Plugin: builtin] 已回复版本信息');
+  } catch (error) {
+    console.error('[Plugin: builtin] 处理消息时发生错误:', error);
+  }
+};
+
+/**
+ * 获取版本信息（完美的类型推导，无需 as 断言）
+ */
+async function getVersionInfo (adapter: string, config: any) {
+  if (!actions) return null;
+
+  try {
+    const data = await actions.call('get_version_info', void 0, adapter, config);
+    return {
+      appName: data.app_name,
+      appVersion: data.app_version,
+      protocolVersion: data.protocol_version,
+    };
+  } catch (error) {
+    console.error('[Plugin: builtin] 获取版本信息失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 格式化版本信息消息
+ */
+function formatVersionMessage (info: { appName: string; appVersion: string; protocolVersion: string; }) {
+  return `NapCat 信息\n版本: ${info.appVersion}\n平台: ${process.platform}${process.arch === 'x64' ? ' (64-bit)' : ''}`;
+}
+
+/**
+ * 发送消息（完美的类型推导）
+ */
+async function sendMessage (event: OB11Message, message: string, adapter: string, config: any) {
+  if (!actions) return;
+
+  const params: OB11PostSendMsg = {
+    message,
+    message_type: event.message_type,
+    ...(event.message_type === 'group' && event.group_id ? { group_id: String(event.group_id) } : {}),
+    ...(event.message_type === 'private' && event.user_id ? { user_id: String(event.user_id) } : {}),
+  };
+
+  try {
+    await actions.call('send_msg', params, adapter, config);
+  } catch (error) {
+    console.error('[Plugin: builtin] 发送消息失败:', error);
+  }
+}
+
+export { plugin_init, plugin_onmessage };

packages/napcat-plugin-builtin/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "napcat-plugin-builtin",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.mjs",
+  "description": "NapCat 内置插件",
+  "author": "NapNeko",
+  "dependencies": {
+    "napcat-onebot": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.1"
+  },
+  "scripts": {
+    "build": "vite build"
+  }
+}

packages/napcat-plugin-builtin/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": [
+    "*.ts",
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}

packages/napcat-plugin-builtin/vite.config.ts

@@ -0,0 +1,77 @@
+import { defineConfig } from 'vite';
+import { resolve } from 'path';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import { builtinModules } from 'module';
+import fs from 'fs';
+
+const nodeModules = [...builtinModules, builtinModules.map((m) => `node:${m}`)].flat();
+
+// 构建后拷贝插件
+function copyToShellPlugin () {
+  return {
+    name: 'copy-to-shell',
+    closeBundle () {
+      try {
+        const sourceDir = resolve(__dirname, 'dist');
+        const targetDir = resolve(__dirname, '../napcat-shell/dist/plugins/builtin');
+        const packageJsonSource = resolve(__dirname, 'package.json');
+
+        // 确保目标目录存在
+        if (!fs.existsSync(targetDir)) {
+          fs.mkdirSync(targetDir, { recursive: true });
+          console.log(`[copy-to-shell] Created directory: ${targetDir}`);
+        }
+
+        // 拷贝 dist 目录下的所有文件
+        const files = fs.readdirSync(sourceDir);
+        let copiedCount = 0;
+
+        files.forEach(file => {
+          const sourcePath = resolve(sourceDir, file);
+          const targetPath = resolve(targetDir, file);
+
+          if (fs.statSync(sourcePath).isFile()) {
+            fs.copyFileSync(sourcePath, targetPath);
+            copiedCount++;
+          }
+        });
+
+        // 拷贝 package.json
+        if (fs.existsSync(packageJsonSource)) {
+          const packageJsonTarget = resolve(targetDir, 'package.json');
+          fs.copyFileSync(packageJsonSource, packageJsonTarget);
+          copiedCount++;
+        }
+
+        console.log(`[copy-to-shell] Successfully copied ${copiedCount} file(s) to ${targetDir}`);
+      } catch (error) {
+        console.error('[copy-to-shell] Failed to copy files:', error);
+        throw error;
+      }
+    },
+  };
+}
+
+export default defineConfig({
+  resolve: {
+    conditions: ['node', 'default'],
+    alias: {
+      '@/napcat-core': resolve(__dirname, '../napcat-core'),
+      '@': resolve(__dirname, '../'),
+    },
+  },
+  build: {
+    sourcemap: false,
+    target: 'esnext',
+    minify: false,
+    lib: {
+      entry: 'index.ts',
+      formats: ['es'],
+      fileName: () => 'index.mjs',
+    },
+    rollupOptions: {
+      external: [...nodeModules],
+    },
+  },
+  plugins: [nodeResolve(), copyToShellPlugin()],
+});

packages/napcat-plugin/index.ts

@@ -1,12 +1,22 @@
+import type { createActionMap } from 'napcat-onebot/action';
 import { EventType } from 'napcat-onebot/event/OneBotEvent';
 import type { PluginModule } from 'napcat-onebot/network/plugin';
 
+/**
+ * 导入 napcat 包时候不使用 @/napcat...，直接使用 napcat...
+ * 因为 @/napcat... 会导致打包时包含整个 napcat 包，而不是只包含需要的部分
+ */
+
+// action 作为参数传递时请用这个
+let actionMap: ReturnType<typeof createActionMap> | undefined = undefined;
+
 const plugin_init: PluginModule['plugin_init'] = async (_core, _obContext, _actions, _instance) => {
   console.log('[Plugin: example] 插件已初始化');
+  actionMap = _actions;
 };
 const plugin_onmessage: PluginModule['plugin_onmessage'] = async (adapter, _core, _obCtx, event, actions, instance) => {
   if (event.post_type === EventType.MESSAGE && event.raw_message.includes('ping')) {
     await actions.get('send_group_msg')?.handle({ group_id: String(event.group_id), message: 'pong' }, adapter, instance.config);
   }
 };
-export { plugin_init, plugin_onmessage };
+export { plugin_init, plugin_onmessage, actionMap };

packages/napcat-plugin/vite.config.ts

@@ -9,7 +9,7 @@ export default defineConfig({
   resolve: {
     conditions: ['node', 'default'],
     alias: {
-      '@/napcat-core': resolve(__dirname, '../core'),
+      '@/napcat-core': resolve(__dirname, '../napcat-core'),
       '@': resolve(__dirname, '../'),
     },
   },

packages/napcat-pty/unixTerminal.ts

@@ -12,7 +12,17 @@ import { ArgvOrCommandLine } from '@homebridge/node-pty-prebuilt-multiarch/src/t
 import { assign } from '@homebridge/node-pty-prebuilt-multiarch/src/utils';
 import { pty_loader } from './prebuild-loader';
 import { fileURLToPath } from 'url';
-export const pty = pty_loader();
+
+// 懒加载pty，避免在模块导入时立即执行pty_loader()
+let _pty: any;
+export const pty: any = new Proxy({}, {
+  get (_target, prop) {
+    if (!_pty) {
+      _pty = pty_loader();
+    }
+    return _pty[prop];
+  }
+});
 
 let helperPath: string;
 helperPath = '../build/Release/spawn-helper';

packages/napcat-shell-loader/launcher-user.bat

@@ -1,5 +1,5 @@
 @echo off
-chcp 65001
+chcp 65001 >nul
 set NAPCAT_PATCH_PACKAGE=%cd%\qqnt.json
 set NAPCAT_LOAD_PATH=%cd%\loadNapCat.js
 set NAPCAT_INJECT_PATH=%cd%\NapCatWinBootHook.dll
@@ -27,6 +27,6 @@ if not exist "%QQpath%" (
 set NAPCAT_MAIN_PATH=%NAPCAT_MAIN_PATH:\=/%
 echo (async () =^> {await import("file:///%NAPCAT_MAIN_PATH%")})() > "%NAPCAT_LOAD_PATH%"
 
-"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %1
+"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %*
 
 pause

packages/napcat-shell-loader/launcher-win10-user.bat

@@ -1,5 +1,5 @@
 @echo off
-chcp 65001
+chcp 65001 >nul
 set NAPCAT_PATCH_PACKAGE=%cd%\qqnt.json
 set NAPCAT_LOAD_PATH=%cd%\loadNapCat.js
 set NAPCAT_INJECT_PATH=%cd%\NapCatWinBootHook.dll
@@ -26,8 +26,9 @@ if not exist "%QQpath%" (
 set NAPCAT_MAIN_PATH=%NAPCAT_MAIN_PATH:\=/%
 echo (async () =^> {await import("file:///%NAPCAT_MAIN_PATH%")})() > "%NAPCAT_LOAD_PATH%"
 
-"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %1
+"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %*
 
-REM "%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" 123456
+REM Optional: -q <QQ_NUMBER> for quick login, omit for QR code login
+REM Example: "%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" -q 123456
 
 pause

packages/napcat-shell-loader/launcher-win10.bat

@@ -1,11 +1,11 @@
 @echo off
-chcp 65001
+chcp 65001 >nul
 net session >nul 2>&1
-if %errorLevel% == 0 (
+if %ERRORLEVEL% == 0 (
     echo Administrator mode detected.
 ) else (
     echo Please run this script in administrator mode.
-    powershell -Command "Start-Process 'cmd.exe' -ArgumentList '/c cd /d \"%cd%\" && \"%~f0\" %1' -Verb runAs" 
+    powershell -Command "Start-Process 'cmd.exe' -ArgumentList '/c cd /d \"%cd%\" && \"%~f0\" %*' -Verb runAs"
     exit
 )
 
@@ -35,6 +35,7 @@ if not exist "%QQPath%" (
 set NAPCAT_MAIN_PATH=%NAPCAT_MAIN_PATH:\=/%
 echo (async () =^> {await import("file:///%NAPCAT_MAIN_PATH%")})() > "%NAPCAT_LOAD_PATH%"
 
-"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %1
+"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %*
 
-REM "%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" 123456
+REM Optional: -q <QQ_NUMBER> for quick login, omit for QR code login
+REM Example: "%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" -q 123456

packages/napcat-shell-loader/launcher.bat

@@ -1,11 +1,11 @@
 @echo off
-chcp 65001
+chcp 65001 >nul
 net session >nul 2>&1
-if %errorLevel% == 0 (
+if %ERRORLEVEL% == 0 (
     echo Administrator mode detected.
 ) else (
     echo Please run this script in administrator mode.
-    powershell -Command "Start-Process 'wt.exe' -ArgumentList 'cmd /c cd /d \"%cd%\" && \"%~f0\" %1' -Verb runAs"
+    powershell -Command "Start-Process 'wt.exe' -ArgumentList 'cmd /c cd /d \"%cd%\" && \"%~f0\" %*' -Verb runAs"
     exit
 )
 
@@ -36,4 +36,4 @@ if not exist "%QQPath%" (
 set NAPCAT_MAIN_PATH=%NAPCAT_MAIN_PATH:\=/%
 echo (async () =^> {await import("file:///%NAPCAT_MAIN_PATH%")})() > "%NAPCAT_LOAD_PATH%"
 
-"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %1
+"%NAPCAT_LAUNCHER_PATH%" "%QQPath%" "%NAPCAT_INJECT_PATH%" %*

packages/napcat-shell-loader/quickLoginExample.bat

@@ -1,4 +1,7 @@
 @echo off
-REM ./launcher.bat 123456
-REM ./launcher-win10.bat 123456
-REM 带有REM的为注释 删掉你需要的系统的那行REM这三个单词 修改QQ本脚本启动即可
+REM 快速登录示例脚本
+REM -q 参数是可选的，不传则使用二维码登录
+REM 
+REM 使用方法（删掉对应系统那行的 REM）：
+REM ./launcher-user.bat 123456
+REM ./launcher-win10-user.bat 123456

packages/napcat-shell/base.ts

@@ -29,12 +29,12 @@ 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-core/helper/ffmpeg/ffmpeg';
-import { connectToNamedPipe } from './pipe';
 import { NativePacketHandler } from 'napcat-core/packet/handler/client';
 import { logSubscription, LogWrapper } from '@/napcat-core/helper/log';
 import { proxiedListenerOf } from '@/napcat-core/helper/proxy-handler';
 import { QQBasicInfoWrapper } from '@/napcat-core/helper/qq-basic-info';
 import { statusHelperSubscription } from '@/napcat-core/helper/status';
+import { applyPendingUpdates } from '@/napcat-webui-backend/src/api/UpdateNapCat';
 // NapCat Shell App ES 入口文件
 async function handleUncaughtExceptions (logger: LogWrapper) {
   process.on('uncaughtException', (err) => {
@@ -127,10 +127,13 @@ async function handleLogin (
 
   const loginListener = new NodeIKernelLoginListener();
   loginListener.onUserLoggedIn = (userid: string) => {
-    logger.logError(`当前账号(${userid})已登录,无法重复登录`);
+    const tips = `当前账号(${userid})已登录,无法重复登录`;
+    logger.logError(tips);
+    WebUiDataRuntime.setQQLoginError(tips);
   };
   loginListener.onQRCodeLoginSucceed = async (loginResult) => {
     context.isLogined = true;
+    WebUiDataRuntime.setQQLoginStatus(true);
     inner_resolve({
       uid: loginResult.uid,
       uin: loginResult.uin,
@@ -169,13 +172,16 @@ async function handleLogin (
       logger.logError('[Core] [Login] Login Error,ErrType: ', errType, ' ErrCode:', errCode);
       if (errType === 1 && errCode === 3) {
         // 二维码过期刷新
+        WebUiDataRuntime.setQQLoginError('二维码已过期，请刷新');
       }
       loginService.getQRCodePicture();
     }
   };
 
   loginListener.onLoginFailed = (...args) => {
-    logger.logError('[Core] [Login] Login Error , ErrInfo: ', JSON.stringify(args));
+    const errInfo = JSON.stringify(args);
+    logger.logError('[Core] [Login] Login Error , ErrInfo: ', errInfo);
+    WebUiDataRuntime.setQQLoginError(`登录失败: ${errInfo}`);
   };
 
   loginService.addKernelLoginListener(proxiedListenerOf(loginListener, logger));
@@ -183,17 +189,29 @@ async function handleLogin (
   return await selfInfo;
 }
 async function handleLoginInner (context: { isLogined: boolean; }, logger: LogWrapper, loginService: NodeIKernelLoginService, quickLoginUin: string | undefined, historyLoginList: LoginListItem[]) {
+  // 注册刷新二维码回调
+  WebUiDataRuntime.setRefreshQRCodeCallback(async () => {
+    loginService.getQRCodePicture();
+  });
+
   WebUiDataRuntime.setQuickLoginCall(async (uin: string) => {
     return await new Promise((resolve) => {
       if (uin) {
         logger.log('正在快速登录 ', uin);
         loginService.quickLoginWithUin(uin).then(res => {
           if (res.loginErrorInfo.errMsg) {
+            WebUiDataRuntime.setQQLoginError(res.loginErrorInfo.errMsg);
+            loginService.getQRCodePicture();
             resolve({ result: false, message: res.loginErrorInfo.errMsg });
+          } else {
+            WebUiDataRuntime.setQQLoginStatus(true);
+            WebUiDataRuntime.setQQLoginError('');
+            resolve({ result: true, message: '' });
           }
-          resolve({ result: true, message: '' });
         }).catch((e) => {
           logger.logError(e);
+          WebUiDataRuntime.setQQLoginError('快速登录发生错误');
+          loginService.getQRCodePicture();
           resolve({ result: false, message: '快速登录发生错误' });
         });
       } else {
@@ -208,6 +226,7 @@ async function handleLoginInner (context: { isLogined: boolean; }, logger: LogWr
         .then(result => {
           if (result.loginErrorInfo.errMsg) {
             logger.logError('快速登录错误：', result.loginErrorInfo.errMsg);
+            WebUiDataRuntime.setQQLoginError(result.loginErrorInfo.errMsg);
             if (!context.isLogined) loginService.getQRCodePicture();
           }
         })
@@ -318,13 +337,14 @@ export async function NCoreInitShell () {
   const pathWrapper = new NapCatPathWrapper();
   const logger = new LogWrapper(pathWrapper.logsPath);
   handleUncaughtExceptions(logger);
+  await applyPendingUpdates(pathWrapper, logger);
 
   // 初始化 FFmpeg 服务
   await FFmpegService.init(pathWrapper.binaryPath, logger);
 
-  if (process.env['NAPCAT_DISABLE_PIPE'] !== '1') {
-    await connectToNamedPipe(logger).catch(e => logger.logError('命名管道连接失败', e));
-  }
+  // 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 用于后续使用
@@ -338,8 +358,8 @@ export async function NCoreInitShell () {
   o3Service.addO3MiscListener(new NodeIO3MiscListener());
 
   logger.log('[NapCat] [Core] NapCat.Core Version: ' + napCatVersion);
+  WebUiDataRuntime.setWorkingEnv(NapCatCoreWorkingEnv.Shell);
   InitWebUi(logger, pathWrapper, logSubscription, statusHelperSubscription).then().catch(e => logger.logError(e));
-
   const engine = wrapper.NodeIQQNTWrapperEngine.get();
   const loginService = wrapper.NodeIKernelLoginService.get();
   let session: NodeIQQNTWrapperSession;
@@ -416,7 +436,6 @@ export async function NCoreInitShell () {
     wrapper,
     session,
     logger,
-    loginService,
     selfInfo,
     basicInfoWrapper,
     pathWrapper,
@@ -432,7 +451,6 @@ export class NapCatShell {
     wrapper: WrapperNodeApi,
     session: NodeIQQNTWrapperSession,
     logger: LogWrapper,
-    loginService: NodeIKernelLoginService,
     selfInfo: SelfInfo,
     basicInfoWrapper: QQBasicInfoWrapper,
     pathWrapper: NapCatPathWrapper,
@@ -444,7 +462,6 @@ export class NapCatShell {
       wrapper,
       session,
       logger,
-      loginService,
       basicInfoWrapper,
       pathWrapper,
     };
@@ -453,7 +470,14 @@ export class NapCatShell {
 
   async InitNapCat () {
     await this.core.initCore();
-    new NapCatOneBot11Adapter(this.core, this.context, this.context.pathWrapper).InitOneBot()
+    // 监听下线通知并同步到 WebUI
+    this.core.event.on('KickedOffLine', (tips: string) => {
+      WebUiDataRuntime.setQQLoginError(tips);
+    });
+    const oneBotAdapter = new NapCatOneBot11Adapter(this.core, this.context, this.context.pathWrapper);
+    // 注册到 WebUiDataRuntime，供调试功能使用
+    WebUiDataRuntime.setOneBotContext(oneBotAdapter);
+    oneBotAdapter.InitOneBot()
       .catch(e => this.context.logger.logError('初始化OneBot失败', e));
   }
 }

packages/napcat-shell/napcat.ts

@@ -1,2 +1,345 @@
 import { NCoreInitShell } from './base';
-NCoreInitShell();
+import { NapCatPathWrapper } from '@/napcat-common/src/path';
+import { LogWrapper } from '@/napcat-core/helper/log';
+import { connectToNamedPipe } from './pipe';
+import { WebUiDataRuntime } from '@/napcat-webui-backend/src/helper/Data';
+import { createProcessManager, type IProcessManager, type IWorkerProcess } from './process-api';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// ES 模块中获取 __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 环境变量配置
+const ENV = {
+  isWorkerProcess: process.env['NAPCAT_WORKER_PROCESS'] === '1',
+  isMultiProcessDisabled: process.env['NAPCAT_DISABLE_MULTI_PROCESS'] === '1',
+  isPipeDisabled: process.env['NAPCAT_DISABLE_PIPE'] === '1',
+} as const;
+
+// 初始化日志
+const pathWrapper = new NapCatPathWrapper();
+const logger = new LogWrapper(pathWrapper.logsPath);
+
+// 进程管理器和当前 Worker 进程引用
+let processManager: IProcessManager | null = null;
+let currentWorker: IWorkerProcess | null = null;
+let isElectron = false;
+let isRestarting = false;
+
+/**
+ * 获取进程类型名称（用于日志）
+ */
+function getProcessTypeName (): string {
+  return isElectron ? 'UtilityProcess' : 'Fork';
+}
+
+/**
+ * 获取 Worker 脚本路径
+ */
+function getWorkerScriptPath (): string {
+  return __filename.endsWith('.mjs')
+    ? path.join(__dirname, 'napcat.mjs')
+    : path.join(__dirname, 'napcat.js');
+}
+
+/**
+ * 检查进程是否存在
+ */
+function isProcessAlive (pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 强制终止进程
+ */
+function forceKillProcess (pid: number): void {
+  try {
+    process.kill(pid, 'SIGKILL');
+    logger.log(`[NapCat] [Process] 已强制终止进程 ${pid}`);
+  } catch (error) {
+    logger.logError(`[NapCat] [Process] 强制终止进程失败:`, error);
+  }
+}
+
+/**
+ * 重启 Worker 进程
+ */
+export async function restartWorker (): Promise<void> {
+  logger.log('[NapCat] [Process] 正在重启Worker进程...');
+  isRestarting = true;
+
+  if (!currentWorker) {
+    logger.logWarn('[NapCat] [Process] 没有运行中的Worker进程');
+    await startWorker(false);
+    isRestarting = false;
+    return;
+  }
+
+  const workerPid = currentWorker.pid;
+  logger.log(`[NapCat] [Process] 准备关闭Worker进程，PID: ${workerPid}`);
+
+  // 1. 通知旧进程准备重启（旧进程会自行退出）
+  currentWorker.postMessage({ type: 'restart-prepare' });
+
+  // 2. 等待进程退出（最多 5 秒，给更多时间让进程自行清理）
+  await new Promise<void>((resolve) => {
+    const timeout = setTimeout(() => {
+      logger.logWarn('[NapCat] [Process] Worker进程未在 5 秒内退出，尝试发送强制关闭信号');
+      currentWorker?.postMessage({ type: 'shutdown' });
+
+      // 再等待 2 秒
+      setTimeout(() => {
+        logger.logWarn('[NapCat] [Process] Worker进程仍未退出，尝试 kill');
+        currentWorker?.kill();
+        resolve();
+      }, 2000);
+    }, 5000);
+
+    currentWorker?.once('exit', () => {
+      clearTimeout(timeout);
+      logger.log('[NapCat] [Process] Worker进程已正常退出');
+      resolve();
+    });
+  });
+
+  // 3. 二次确认进程是否真的被终止（兜底检查）
+  if (workerPid) {
+    logger.log(`[NapCat] [Process] 检查进程 ${workerPid} 是否已终止...`);
+
+    if (isProcessAlive(workerPid)) {
+      logger.logWarn(`[NapCat] [Process] 进程 ${workerPid} 仍在运行，尝试强制杀掉（兜底）`);
+      forceKillProcess(workerPid);
+
+      // 等待 1 秒后再次检查
+      await new Promise(resolve => setTimeout(resolve, 1000));
+
+      if (isProcessAlive(workerPid)) {
+        logger.logError(`[NapCat] [Process] 进程 ${workerPid} 无法终止，可能需要手动处理`);
+      } else {
+        logger.log(`[NapCat] [Process] 进程 ${workerPid} 已被强制终止`);
+      }
+    } else {
+      logger.log(`[NapCat] [Process] 进程 ${workerPid} 已确认终止`);
+    }
+  }
+
+  // 4. 等待 3 秒后启动新进程
+  logger.log('[NapCat] [Process] Worker进程已关闭，等待 3 秒后启动新进程...');
+  await new Promise(resolve => setTimeout(resolve, 3000));
+
+  // 5. 启动新进程（重启模式不传递快速登录参数）
+  await startWorker(false);
+  isRestarting = false;
+  logger.log('[NapCat] [Process] Worker进程重启完成');
+}
+
+/**
+ * 启动 Worker 进程
+ * @param passQuickLogin 是否传递快速登录参数，默认为 true，重启时为 false
+ */
+async function startWorker (passQuickLogin: boolean = true): Promise<void> {
+  if (!processManager) {
+    throw new Error('进程管理器未初始化');
+  }
+
+  const workerScript = getWorkerScriptPath();
+  const processType = getProcessTypeName();
+
+  // 只在首次启动时传递 -q 或 --qq 参数给 worker 进程
+  const workerArgs: string[] = [];
+  if (passQuickLogin) {
+    const args = process.argv.slice(2);
+    const qIndex = args.findIndex(arg => arg === '-q' || arg === '--qq');
+    if (qIndex !== -1 && qIndex + 1 < args.length) {
+      const qFlag = args[qIndex];
+      const qValue = args[qIndex + 1];
+      if (qFlag && qValue) {
+        workerArgs.push(qFlag, qValue);
+      }
+    }
+  }
+
+  const child = processManager.createWorker(workerScript, workerArgs, {
+    env: {
+      ...process.env,
+      NAPCAT_WORKER_PROCESS: '1',
+    },
+    stdio: isElectron ? 'pipe' : ['inherit', 'pipe', 'pipe', 'ipc'],
+  });
+
+  currentWorker = child;
+
+  // 监听标准输出（直接转发）
+  if (child.stdout) {
+    child.stdout.on('data', (data: Buffer) => {
+      process.stdout.write(data);
+    });
+  }
+
+  // 监听标准错误（直接转发）
+  if (child.stderr) {
+    child.stderr.on('data', (data: Buffer) => {
+      process.stderr.write(data);
+    });
+  }
+
+  // 监听子进程消息
+  child.on('message', (msg: unknown) => {
+    logger.log(`[NapCat] [${processType}] 收到Worker消息:`, msg);
+
+    // 处理重启请求
+    if (typeof msg === 'object' && msg !== null && 'type' in msg && msg.type === 'restart') {
+      logger.log(`[NapCat] [${processType}] 收到重启请求，正在重启Worker进程...`);
+      restartWorker().catch(e => {
+        logger.logError(`[NapCat] [${processType}] 重启Worker进程失败:`, e);
+      });
+    }
+  });
+
+  // 监听子进程退出
+  child.on('exit', (code: unknown) => {
+    const exitCode = typeof code === 'number' ? code : 0;
+    if (exitCode !== 0) {
+      logger.logError(`[NapCat] [${processType}] Worker进程退出，退出码: ${exitCode}`);
+    } else {
+      logger.log(`[NapCat] [${processType}] Worker进程正常退出`);
+    }
+    // 如果不是由于主动重启引起的退出，尝试自动重新拉起（保留快速登录参数）
+    if (!isRestarting) {
+      logger.logWarn(`[NapCat] [${processType}] Worker进程意外退出，正在尝试重新拉起...`);
+      startWorker(true).catch(e => {
+        logger.logError(`[NapCat] [${processType}] 重新拉起Worker进程失败:`, e);
+      });
+    }
+  });
+
+  child.on('spawn', () => {
+    logger.log(`[NapCat] [${processType}] Worker进程已生成`);
+  });
+}
+
+/**
+ * 启动 Master 进程
+ */
+async function startMasterProcess (): Promise<void> {
+  const processType = getProcessTypeName();
+  logger.log(`[NapCat] [${processType}] Master进程启动，PID: ${process.pid}`);
+
+  // 连接命名管道（可通过环境变量禁用）
+  if (!ENV.isPipeDisabled) {
+    await connectToNamedPipe(logger).catch(e =>
+      logger.logError('命名管道连接失败', e)
+    );
+  } else {
+    logger.log(`[NapCat] [${processType}] 命名管道已禁用 (NAPCAT_DISABLE_PIPE=1)`);
+  }
+
+  // 启动 Worker 进程
+  await startWorker();
+
+  // 优雅关闭处理
+  const shutdown = (signal: string) => {
+    logger.log(`[NapCat] [Process] 收到${signal}信号，正在关闭...`);
+
+    if (currentWorker) {
+      currentWorker.postMessage({ type: 'shutdown' });
+      setTimeout(() => {
+        currentWorker?.kill();
+        process.exit(0);
+      }, 1000);
+    } else {
+      process.exit(0);
+    }
+  };
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+}
+
+/**
+ * 启动 Worker 进程（子进程入口）
+ */
+async function startWorkerProcess (): Promise<void> {
+  if (!processManager) {
+    throw new Error('进程管理器未初始化');
+  }
+
+  const processType = getProcessTypeName();
+  logger.log(`[NapCat] [${processType}] Worker进程启动，PID: ${process.pid}`);
+
+  // 监听来自父进程的消息
+  processManager.onParentMessage((msg: unknown) => {
+    if (typeof msg === 'object' && msg !== null && 'type' in msg) {
+      if (msg.type === 'restart-prepare') {
+        logger.log(`[NapCat] [${processType}] 收到重启准备信号，正在主动退出...`);
+        setTimeout(() => {
+          process.exit(0);
+        }, 100);
+      } else if (msg.type === 'shutdown') {
+        logger.log(`[NapCat] [${processType}] 收到关闭信号，正在退出...`);
+        process.exit(0);
+      }
+    }
+  });
+
+  // 注册重启进程函数到 WebUI
+  WebUiDataRuntime.setRestartProcessCall(async () => {
+    try {
+      const success = processManager!.sendToParent({ type: 'restart' });
+
+      if (success) {
+        return { result: true, message: '进程重启请求已发送' };
+      } else {
+        return { result: false, message: '无法与主进程通信' };
+      }
+    } catch (e) {
+      logger.logError('[NapCat] [Process] 发送重启请求失败:', e);
+      return {
+        result: false,
+        message: '发送重启请求失败: ' + (e as Error).message
+      };
+    }
+  });
+
+  // 启动 NapCat 核心
+  await NCoreInitShell();
+}
+
+/**
+ * 主入口
+ */
+async function main (): Promise<void> {
+  // 单进程模式：直接启动核心
+  if (ENV.isMultiProcessDisabled) {
+    logger.log('[NapCat] [SingleProcess] 多进程模式已禁用，直接启动核心');
+    await NCoreInitShell();
+    return;
+  }
+
+  // 多进程模式：初始化进程管理器
+  const result = await createProcessManager();
+  processManager = result.manager;
+  isElectron = result.isElectron;
+
+  logger.log(`[NapCat] [Process] 检测到 ${isElectron ? 'Electron' : 'Node.js'} 环境`);
+
+  // 根据进程类型启动
+  if (ENV.isWorkerProcess) {
+    await startWorkerProcess();
+  } else {
+    await startMasterProcess();
+  }
+}
+
+// 启动应用
+main().catch((e: Error) => {
+  logger.logError('[NapCat] [Process] 启动失败:', e);
+  process.exit(1);
+});

packages/napcat-shell/process-api.ts

@@ -0,0 +1,178 @@
+import type { Readable } from 'stream';
+import type { fork as forkType } from 'child_process';
+
+// 扩展 Process 类型以支持 parentPort
+declare global {
+  namespace NodeJS {
+    interface Process {
+      parentPort?: {
+        on (event: 'message', listener: (e: { data: unknown; }) => void): void;
+        postMessage (message: unknown): void;
+      };
+    }
+  }
+}
+
+/**
+ * 统一的进程接口
+ */
+export interface IWorkerProcess {
+  readonly pid: number | undefined;
+  readonly stdout: Readable | null;
+  readonly stderr: Readable | null;
+
+  postMessage (message: unknown): void;
+  kill (): boolean;
+  on (event: string, listener: (...args: unknown[]) => void): void;
+  once (event: string, listener: (...args: unknown[]) => void): void;
+}
+
+/**
+ * 进程创建选项
+ */
+export interface ProcessOptions {
+  env: NodeJS.ProcessEnv;
+  stdio: 'pipe' | 'ignore' | 'inherit' | Array<'pipe' | 'ignore' | 'inherit' | 'ipc'>;
+}
+
+/**
+ * 进程管理器接口
+ */
+export interface IProcessManager {
+  createWorker (modulePath: string, args: string[], options: ProcessOptions): IWorkerProcess;
+  onParentMessage (handler: (message: unknown) => void): void;
+  sendToParent (message: unknown): boolean;
+}
+
+/**
+ * Electron utilityProcess 包装器
+ */
+class ElectronProcessManager implements IProcessManager {
+  private utilityProcess: {
+    fork (modulePath: string, args: string[], options: unknown): unknown;
+  };
+
+  constructor (utilityProcess: { fork (modulePath: string, args: string[], options: unknown): unknown; }) {
+    this.utilityProcess = utilityProcess;
+  }
+
+  createWorker (modulePath: string, args: string[], options: ProcessOptions): IWorkerProcess {
+    const child: any = this.utilityProcess.fork(modulePath, args, options);
+
+    return {
+      pid: child.pid as number | undefined,
+      stdout: child.stdout as Readable | null,
+      stderr: child.stderr as Readable | null,
+
+      postMessage (message: unknown): void {
+        child.postMessage(message);
+      },
+
+      kill (): boolean {
+        return child.kill() as boolean;
+      },
+
+      on (event: string, listener: (...args: unknown[]) => void): void {
+        child.on(event, listener);
+      },
+
+      once (event: string, listener: (...args: unknown[]) => void): void {
+        child.once(event, listener);
+      },
+    };
+  }
+
+  onParentMessage (handler: (message: unknown) => void): void {
+    if (process.parentPort) {
+      process.parentPort.on('message', (e: { data: unknown; }) => {
+        handler(e.data);
+      });
+    }
+  }
+
+  sendToParent (message: unknown): boolean {
+    if (process.parentPort) {
+      process.parentPort.postMessage(message);
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * Node.js child_process 包装器
+ */
+class NodeProcessManager implements IProcessManager {
+  private forkFn: typeof forkType;
+
+  constructor (forkFn: typeof forkType) {
+    this.forkFn = forkFn;
+  }
+
+  createWorker (modulePath: string, args: string[], options: ProcessOptions): IWorkerProcess {
+    const child = this.forkFn(modulePath, args, options as any);
+
+    return {
+      pid: child.pid,
+      stdout: child.stdout,
+      stderr: child.stderr,
+
+      postMessage (message: unknown): void {
+        if (child.send) {
+          child.send(message as any);
+        }
+      },
+
+      kill (): boolean {
+        return child.kill();
+      },
+
+      on (event: string, listener: (...args: unknown[]) => void): void {
+        child.on(event, listener);
+      },
+
+      once (event: string, listener: (...args: unknown[]) => void): void {
+        child.once(event, listener);
+      },
+    };
+  }
+
+  onParentMessage (handler: (message: unknown) => void): void {
+    process.on('message', (message: unknown) => {
+      handler(message);
+    });
+  }
+
+  sendToParent (message: unknown): boolean {
+    if (process.send) {
+      process.send(message as any);
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * 检测运行环境并创建对应的进程管理器
+ */
+export async function createProcessManager (): Promise<{
+  manager: IProcessManager;
+  isElectron: boolean;
+}> {
+  const isElectron = typeof process.versions['electron'] !== 'undefined';
+
+  if (isElectron) {
+    // @ts-ignore - electron 运行时存在但类型声明可能缺失
+    const electron = await import('electron');
+    return {
+      manager: new ElectronProcessManager(electron.utilityProcess),
+      isElectron: true,
+    };
+  } else {
+    const { fork } = await import('child_process');
+    return {
+      manager: new NodeProcessManager(fork),
+      isElectron: false,
+    };
+  }
+}

packages/napcat-shell/vite.config.ts

@@ -9,9 +9,9 @@ import react from '@vitejs/plugin-react-swc';
 
 // 依赖排除
 const external = [
-  'silk-wasm',
   'ws',
   'express',
+  'electron'
 ];
 
 const nodeModules = [...builtinModules, builtinModules.map((m) => `node:${m}`)].flat();
@@ -27,6 +27,7 @@ const ShellBaseConfigPlugin: PluginOption[] = [
     targets: [
       { src: '../napcat-native/', dest: 'dist/native', flatten: false },
       { src: '../napcat-webui-frontend/dist/', dest: 'dist/static/', flatten: false },
+      { src: '../napcat-webui-backend/src/assets/sw_template.js', dest: 'dist/static/' },
       { src: '../napcat-core/external/napcat.json', dest: 'dist/config/' },
       { src: '../../package.json', dest: 'dist' },
       { src: '../napcat-shell-loader', dest: 'dist' },
@@ -55,7 +56,6 @@ const ShellBaseConfig = (source_map: boolean = 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'],

packages/napcat-vite/package.json

@@ -1,24 +1,24 @@
 {
-    "name": "napcat-vite",
-    "version": "0.0.1",
-    "private": true,
-    "type": "module",
-    "main": "index.ts",
-    "scripts": {
-        "build": "vite build"
+  "name": "napcat-vite",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "index.ts",
+  "scripts": {
+    "_build": "vite build"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.ts"
     },
-    "exports": {
-        ".": {
-            "import": "./index.ts"
-        },
-        "./*": {
-            "import": "./*"
-        }
-    },
-    "devDependencies": {
-        "@types/node": "^22.0.1"
-    },
-    "engines": {
-        "node": ">=18.0.0"
+    "./*": {
+      "import": "./*"
     }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
 }

packages/napcat-vite/vite-plugin-version.js

@@ -6,8 +6,49 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+/**
+ * SemVer 2.0 正则表达式
+ * 格式: 主版本号.次版本号.修订号[-先行版本号][+版本编译信息]
+ * 参考: https://semver.org/lang/zh-CN/
+ */
+const SEMVER_REGEX = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+
+/**
+ * Validate version format according to SemVer 2.0 specification
+ * @param {string} version - The version string to validate (with or without 'v' prefix)
+ * @returns {{ valid: boolean, normalized: string, major: number, minor: number, patch: number, prerelease: string|null, buildmetadata: string|null }}
+ */
+function validateVersion (version) {
+  if (!version || typeof version !== 'string') {
+    return { valid: false, normalized: '1.0.0-dev', major: 1, minor: 0, patch: 0, prerelease: 'dev', buildmetadata: null };
+  }
+
+  const match = version.trim().match(SEMVER_REGEX);
+  if (match) {
+    const major = parseInt(match[1], 10);
+    const minor = parseInt(match[2], 10);
+    const patch = parseInt(match[3], 10);
+    const prerelease = match[4] || null;
+    const buildmetadata = match[5] || null;
+
+    // 构建标准化版本号（不带 v 前缀）
+    let normalized = `${major}.${minor}.${patch}`;
+    if (prerelease) normalized += `-${prerelease}`;
+    if (buildmetadata) normalized += `+${buildmetadata}`;
+
+    return { valid: true, normalized, major, minor, patch, prerelease, buildmetadata };
+  }
+  return { valid: false, normalized: '1.0.0-dev', major: 1, minor: 0, patch: 0, prerelease: 'dev', buildmetadata: null };
+}
+
 /**
  * NapCat Vite Plugin: fetches latest GitHub tag (not release) and injects into import.meta.env
+ * 
+ * 版本号来源优先级:
+ * 1. 环境变量 NAPCAT_VERSION (用于 CI 构建)
+ * 2. 缓存的 GitHub tag
+ * 3. 从 GitHub API 获取最新 tag
+ * 4. 兆底版本号: 1.0.0-dev
  */
 export default function vitePluginNapcatVersion () {
   const pluginDir = path.resolve(__dirname, 'dist');
@@ -16,6 +57,9 @@ export default function vitePluginNapcatVersion () {
   const repo = 'NapCatQQ';
   const maxAgeMs = 24 * 60 * 60 * 1000; // cache 1 day
   const githubToken = process.env.GITHUB_TOKEN;
+  // CI 构建时可通过环境变量直接指定版本号
+  const envVersion = process.env.NAPCAT_VERSION;
+  const fallbackVersion = '1.0.0-dev';
 
   fs.mkdirSync(pluginDir, { recursive: true });
 
@@ -26,7 +70,7 @@ export default function vitePluginNapcatVersion () {
         const data = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
         if (data?.tag) return data.tag;
       }
-    } catch {}
+    } catch { }
     return null;
   }
 
@@ -36,7 +80,7 @@ export default function vitePluginNapcatVersion () {
         cacheFile,
         JSON.stringify({ tag, time: new Date().toISOString() }, null, 2)
       );
-    } catch {}
+    } catch { }
   }
 
   async function fetchLatestTag () {
@@ -58,7 +102,14 @@ export default function vitePluginNapcatVersion () {
             try {
               const json = JSON.parse(data);
               if (Array.isArray(json) && json[0]?.name) {
-                resolve(json[0].name);
+                const tagName = json[0].name;
+                const { valid, normalized } = validateVersion(tagName);
+                if (valid) {
+                  resolve(normalized);
+                } else {
+                  console.warn(`[vite-plugin-napcat-version] Invalid tag format: ${tagName}, expected vX.X.X`);
+                  reject(new Error(`Invalid tag format: ${tagName}, expected vX.X.X`));
+                }
               } else reject(new Error('Invalid GitHub tag response'));
             } catch (e) {
               reject(e);
@@ -71,6 +122,17 @@ export default function vitePluginNapcatVersion () {
   }
 
   async function getVersion () {
+    // 优先使用环境变量指定的版本号 (CI 构建)
+    if (envVersion) {
+      const { valid, normalized } = validateVersion(envVersion);
+      if (valid) {
+        console.log(`[vite-plugin-napcat-version] Using version from NAPCAT_VERSION env: ${normalized}`);
+        return normalized;
+      } else {
+        console.warn(`[vite-plugin-napcat-version] Invalid NAPCAT_VERSION format: ${envVersion}, falling back to fetch`);
+      }
+    }
+
     const cached = readCache();
     if (cached) return cached;
     try {
@@ -79,7 +141,7 @@ export default function vitePluginNapcatVersion () {
       return tag;
     } catch (e) {
       console.warn('[vite-plugin-napcat-version] Failed to fetch tag:', e.message);
-      return cached ?? 'v0.0.0';
+      return cached ?? fallbackVersion;
     }
   }
 
@@ -110,8 +172,11 @@ export default function vitePluginNapcatVersion () {
             lastTag = tag;
             ctx.server?.ws.send({ type: 'full-reload' });
           }
-        } catch {}
+        } catch { }
       }
     },
   };
 }
+
+// Export validateVersion for external use
+export { validateVersion };

packages/napcat-webui-backend/index.ts

@@ -22,6 +22,14 @@ import { existsSync, readFileSync } from 'node:fs'; // 引入multer用于错误
 import { ILogWrapper } from 'napcat-common/src/log-interface';
 import { ISubscription } from 'napcat-common/src/subscription-interface';
 import { IStatusHelperSubscription } from '@/napcat-common/src/status-interface';
+import { handleDebugWebSocket } from '@/napcat-webui-backend/src/api/Debug';
+import compression from 'compression';
+import { napCatVersion } from 'napcat-common/src/version';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 // 实例化Express
 const app = express();
 /**
@@ -34,6 +42,7 @@ export let WebUiConfig: WebUiConfigWrapper;
 export let webUiPathWrapper: NapCatPathWrapper;
 export let logSubscription: ISubscription;
 export let statusHelperSubscription: IStatusHelperSubscription;
+export let webUiLogger: ILogWrapper | null = null;
 const MAX_PORT_TRY = 100;
 
 export let webUiRuntimePort = 6099;
@@ -92,10 +101,17 @@ export async function InitWebUi (logger: ILogWrapper, pathWrapper: NapCatPathWra
   webUiPathWrapper = pathWrapper;
   logSubscription = Subscription;
   statusHelperSubscription = statusSubscription;
+  webUiLogger = logger;
   WebUiConfig = new WebUiConfigWrapper();
   let config = await WebUiConfig.GetWebUIConfig();
 
-  // 检查并更新默认密码 - 最高优先级
+  // 检查是否禁用WebUI（若禁用则不进行密码检测）
+  if (config.disableWebUI) {
+    logger.log('[NapCat] [WebUi] WebUI is disabled by configuration.');
+    return;
+  }
+
+  // 检查并更新默认密码（仅在启用WebUI时）
   if (config.token === 'napcat' || !config.token) {
     const randomToken = process.env['NAPCAT_WEBUI_SECRET_KEY'] || getRandomToken(8);
     await WebUiConfig.UpdateWebUIConfig({ token: randomToken });
@@ -112,12 +128,6 @@ export async function InitWebUi (logger: ILogWrapper, pathWrapper: NapCatPathWra
   // 存储启动时的初始token用于鉴权
   setInitialWebUiToken(config.token);
 
-  // 检查是否禁用WebUI
-  if (config.disableWebUI) {
-    logger.log('[NapCat] [WebUi] WebUI is disabled by configuration.');
-    return;
-  }
-
   const [host, port, token] = await InitPort(config);
   webUiRuntimePort = port;
   if (port === 0) {
@@ -142,39 +152,118 @@ export async function InitWebUi (logger: ILogWrapper, pathWrapper: NapCatPathWra
   // ------------注册中间件------------
   // 使用express的json中间件
   app.use(express.json());
+  // 启用gzip压缩（对所有响应启用，阈值1KB）
+  app.use(compression({
+    level: 6, // 压缩级别 1-9，6 是性能和压缩率的平衡点
+    threshold: 1024, // 只压缩大于 1KB 的响应
+    filter: (req, res) => {
+      // 不压缩 SSE 和 WebSocket 升级请求
+      if (req.headers['accept'] === 'text/event-stream') {
+        return false;
+      }
+      // 使用默认过滤器
+      return compression.filter(req, res);
+    },
+  }));
 
   // CORS中间件
   // TODO:
   app.use(cors);
 
-  // 如果是webui字体文件，挂载字体文件
-  app.use('/webui/fonts/AaCute.woff', async (_req, res, next) => {
-    const isFontExist = await WebUiConfig.CheckWebUIFontExist();
-    if (isFontExist) {
-      res.sendFile(WebUiConfig.GetWebUIFontPath());
+  // 自定义字体文件路由 - 返回用户上传的字体文件
+  app.use('/webui/fonts/CustomFont.woff', async (_req, res) => {
+    const fontPath = await WebUiConfig.GetWebUIFontPath();
+    if (fontPath) {
+      res.sendFile(fontPath);
     } else {
-      next();
+      res.status(404).send('Custom font not found');
     }
   });
 
   // 如果是自定义色彩，构建一个css文件
   app.use('/files/theme.css', async (_req, res) => {
-    const colors = await WebUiConfig.GetTheme();
+    const theme = await WebUiConfig.GetTheme();
+    const fontMode = theme.fontMode || 'system';
 
-    let css = ':root, .light, [data-theme="light"] {';
-    for (const key in colors.light) {
-      css += `${key}: ${colors.light[key]};`;
+    let css = '';
+
+    // 生成字体 @font-face
+    if (fontMode === 'aacute') {
+      css += `
+@font-face {
+  font-family: 'Aa偷吃可爱长大的';
+  src: url('/webui/fonts/AaCute.woff') format('woff');
+  font-display: swap;
+}
+`;
+    } else if (fontMode === 'custom') {
+      css += `
+@font-face {
+  font-family: 'CustomFont';
+  src: url('/webui/fonts/CustomFont.woff') format('woff');
+  font-display: swap;
+}
+`;
+    }
+
+    // 生成颜色主题和字体变量
+    css += ':root, .light, [data-theme="light"] {';
+    for (const key in theme.light) {
+      css += `${key}: ${theme.light[key]};`;
+    }
+    // 添加字体变量
+    if (fontMode === 'aacute') {
+      css += "--font-family-base: 'Aa偷吃可爱长大的', var(--font-family-fallbacks) !important;";
+    } else if (fontMode === 'custom') {
+      css += "--font-family-base: 'CustomFont', var(--font-family-fallbacks) !important;";
+    } else {
+      css += '--font-family-base: var(--font-family-fallbacks) !important;';
     }
     css += '}';
+
     css += '.dark, [data-theme="dark"] {';
-    for (const key in colors.dark) {
-      css += `${key}: ${colors.dark[key]};`;
+    for (const key in theme.dark) {
+      css += `${key}: ${theme.dark[key]};`;
+    }
+    // 添加字体变量
+    if (fontMode === 'aacute') {
+      css += "--font-family-base: 'Aa偷吃可爱长大的', var(--font-family-fallbacks) !important;";
+    } else if (fontMode === 'custom') {
+      css += "--font-family-base: 'CustomFont', var(--font-family-fallbacks) !important;";
+    } else {
+      css += '--font-family-base: var(--font-family-fallbacks) !important;';
     }
     css += '}';
 
     res.send(css);
   });
 
+  // 动态生成 sw.js
+  app.get('/webui/sw.js', async (_req, res) => {
+    try {
+      // 读取模板文件
+      let templatePath = resolve(__dirname, 'static', 'sw_template.js');
+      if (!existsSync(templatePath)) {
+        templatePath = resolve(__dirname, 'src', 'assets', 'sw_template.js');
+      }
+
+      let swContent = readFileSync(templatePath, 'utf-8');
+
+      // 替换版本号
+      // 使用 napCatVersion，如果为 alpha 则尝试加上时间戳或其他标识以避免缓存冲突，或者直接使用
+      // 用户要求控制 sw.js 版本，napCatVersion 是核心控制点
+      swContent = swContent.replace('{{VERSION}}', napCatVersion);
+
+      res.header('Content-Type', 'application/javascript');
+      res.header('Service-Worker-Allowed', '/webui/');
+      res.header('Cache-Control', 'no-cache, no-store, must-revalidate');
+      res.send(swContent);
+    } catch (error) {
+      console.error('[NapCat] [WebUi] Error generating sw.js', error);
+      res.status(500).send('Error generating service worker');
+    }
+  });
+
   // ------------中间件结束------------
 
   // ------------挂载路由------------
@@ -187,7 +276,15 @@ export async function InitWebUi (logger: ILogWrapper, pathWrapper: NapCatPathWra
   const isHttps = !!sslCerts;
   const server = isHttps && sslCerts ? createHttpsServer(sslCerts, app) : createServer(app);
   server.on('upgrade', (request, socket, head) => {
-    terminalManager.initialize(request, socket, head, logger);
+    const url = new URL(request.url || '', `http://${request.headers.host}`);
+
+    // 检查是否是调试 WebSocket 连接
+    if (url.pathname.startsWith('/api/Debug/ws')) {
+      handleDebugWebSocket(request, socket, head);
+    } else {
+      // 默认为终端 WebSocket
+      terminalManager.initialize(request, socket, head, logger);
+    }
   });
   // 挂载API接口
   app.use('/api', ALLRouter);

packages/napcat-webui-backend/package.json

@@ -16,9 +16,11 @@
     }
   },
   "dependencies": {
+    "@simplewebauthn/server": "^13.2.2",
     "@sinclair/typebox": "^0.34.38",
     "ajv": "^8.13.0",
     "compressing": "^1.10.3",
+    "compression": "^1.8.1",
     "express": "^5.0.0",
     "express-rate-limit": "^7.5.0",
     "json5": "^2.2.3",
@@ -28,6 +30,7 @@
     "ws": "^8.18.3"
   },
   "devDependencies": {
+    "@types/compression": "^1.8.1",
     "@types/express": "^5.0.0",
     "@types/multer": "^1.4.12",
     "@types/node": "^22.0.1",

packages/napcat-webui-backend/src/api/Auth.ts

@@ -1,5 +1,6 @@
 import { RequestHandler } from 'express';
 import { AuthHelper } from '@/napcat-webui-backend/src/helper/SignToken';
+import { PasskeyHelper } from '@/napcat-webui-backend/src/helper/PasskeyHelper';
 import { WebUiDataRuntime } from '@/napcat-webui-backend/src/helper/Data';
 import { sendSuccess, sendError } from '@/napcat-webui-backend/src/utils/response';
 import { isEmpty } from '@/napcat-webui-backend/src/utils/check';
@@ -148,3 +149,115 @@ export const UpdateTokenHandler: RequestHandler = async (req, res) => {
     return sendError(res, `Failed to update token: ${e.message}`);
   }
 };
+
+// 生成Passkey注册选项
+export const GeneratePasskeyRegistrationOptionsHandler: RequestHandler = async (_req, res) => {
+  try {
+    // 使用固定用户ID，因为WebUI只有一个用户
+    const userId = 'napcat-user';
+    const userName = 'NapCat User';
+
+    // 从请求头获取host来确定RP_ID
+    const host = _req.get('host') || 'localhost';
+    const hostname = host.split(':')[0] || 'localhost'; // 移除端口
+    // 对于本地开发，使用localhost而不是IP地址
+    const rpId = (hostname === '127.0.0.1' || hostname === 'localhost') ? 'localhost' : hostname;
+
+    const options = await PasskeyHelper.generateRegistrationOptions(userId, userName, rpId);
+    return sendSuccess(res, options);
+  } catch (error) {
+    return sendError(res, `Failed to generate registration options: ${(error as Error).message}`);
+  }
+};
+
+// 验证Passkey注册
+export const VerifyPasskeyRegistrationHandler: RequestHandler = async (req, res) => {
+  try {
+    const { response } = req.body;
+    if (!response) {
+      return sendError(res, 'Response is required');
+    }
+
+    const origin = req.get('origin') || req.protocol + '://' + req.get('host');
+    const host = req.get('host') || 'localhost';
+    const hostname = host.split(':')[0] || 'localhost'; // 移除端口
+    // 对于本地开发，使用localhost而不是IP地址
+    const rpId = (hostname === '127.0.0.1' || hostname === 'localhost') ? 'localhost' : hostname;
+    const userId = 'napcat-user';
+    const verification = await PasskeyHelper.verifyRegistration(userId, response, origin, rpId);
+
+    if (verification.verified) {
+      return sendSuccess(res, { verified: true });
+    } else {
+      return sendError(res, 'Registration failed');
+    }
+  } catch (error) {
+    return sendError(res, `Registration verification failed: ${(error as Error).message}`);
+  }
+};
+
+// 生成Passkey认证选项
+export const GeneratePasskeyAuthenticationOptionsHandler: RequestHandler = async (_req, res) => {
+  try {
+    const userId = 'napcat-user';
+
+    if (!(await PasskeyHelper.hasPasskeys(userId))) {
+      return sendError(res, 'No passkeys registered');
+    }
+
+    // 从请求头获取host来确定RP_ID
+    const host = _req.get('host') || 'localhost';
+    const hostname = host.split(':')[0] || 'localhost'; // 移除端口
+    // 对于本地开发，使用localhost而不是IP地址
+    const rpId = (hostname === '127.0.0.1' || hostname === 'localhost') ? 'localhost' : hostname;
+
+    const options = await PasskeyHelper.generateAuthenticationOptions(userId, rpId);
+    return sendSuccess(res, options);
+  } catch (error) {
+    return sendError(res, `Failed to generate authentication options: ${(error as Error).message}`);
+  }
+};
+
+// 验证Passkey认证
+export const VerifyPasskeyAuthenticationHandler: RequestHandler = async (req, res) => {
+  try {
+    const { response } = req.body;
+    if (!response) {
+      return sendError(res, 'Response is required');
+    }
+
+    // 获取WebUI配置用于限速检查
+    const WebUiConfigData = await WebUiConfig.GetWebUIConfig();
+    // 获取客户端IP
+    const clientIP = req.ip || req.socket.remoteAddress || '';
+
+    // 检查登录频率
+    if (!WebUiDataRuntime.checkLoginRate(clientIP, WebUiConfigData.loginRate)) {
+      return sendError(res, 'login rate limit');
+    }
+
+    const origin = req.get('origin') || req.protocol + '://' + req.get('host');
+    const host = req.get('host') || 'localhost';
+    const hostname = host.split(':')[0] || 'localhost'; // 移除端口
+    // 对于本地开发，使用localhost而不是IP地址
+    const rpId = (hostname === '127.0.0.1' || hostname === 'localhost') ? 'localhost' : hostname;
+    const userId = 'napcat-user';
+    const verification = await PasskeyHelper.verifyAuthentication(userId, response, origin, rpId);
+
+    if (verification.verified) {
+      // 使用与普通登录相同的凭证签发
+      const initialToken = getInitialWebUiToken();
+      if (!initialToken) {
+        return sendError(res, 'Server token not initialized');
+      }
+      const signCredential = Buffer.from(JSON.stringify(AuthHelper.signCredential(AuthHelper.generatePasswordHash(initialToken)))).toString('base64');
+      return sendSuccess(res, {
+        Credential: signCredential,
+      });
+    } else {
+      return sendError(res, 'Authentication failed');
+    }
+  } catch (error) {
+    return sendError(res, `Authentication verification failed: ${(error as Error).message}`);
+  }
+};

packages/napcat-webui-backend/src/api/BaseInfo.ts

@@ -3,12 +3,143 @@ import { WebUiDataRuntime } from '@/napcat-webui-backend/src/helper/Data';
 
 import { sendSuccess } from '@/napcat-webui-backend/src/utils/response';
 import { WebUiConfig } from '@/napcat-webui-backend/index';
+import { getLatestTag, getAllTags, compareSemVer } from 'napcat-common/src/helper';
+import { getLatestActionArtifacts } from '@/napcat-common/src/mirror';
+import { NapCatCoreWorkingEnv } from '@/napcat-webui-backend/src/types';
 
 export const GetNapCatVersion: RequestHandler = (_, res) => {
   const data = WebUiDataRuntime.GetNapCatVersion();
   sendSuccess(res, { version: data });
 };
 
+export const getLatestTagHandler: RequestHandler = async (_, res) => {
+  try {
+    const latestTag = await getLatestTag();
+    sendSuccess(res, latestTag);
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch latest tag', details: (error as Error).message });
+  }
+};
+
+/**
+ * 版本信息接口
+ */
+export interface VersionInfo {
+  tag: string;
+  type: 'release' | 'prerelease' | 'action';
+  /** Action artifact 专用字段 */
+  artifactId?: number;
+  artifactName?: string;
+  createdAt?: string;
+  expiresAt?: string;
+  size?: number;
+  workflowRunId?: number;
+  headSha?: string;
+}
+
+/**
+ * 获取所有可用的版本（release + action artifacts）
+ * 支持分页，懒加载：根据 type 参数只获取需要的版本类型
+ */
+export const getAllReleasesHandler: RequestHandler = async (req, res) => {
+  try {
+    const page = parseInt(req.query['page'] as string) || 1;
+    const pageSize = parseInt(req.query['pageSize'] as string) || 20;
+    const typeFilter = req.query['type'] as string | undefined; // 'release' | 'action' | 'all'
+    const searchQuery = (req.query['search'] as string || '').toLowerCase().trim();
+
+    let versions: VersionInfo[] = [];
+    let actionVersions: VersionInfo[] = [];
+    let usedMirror = '';
+
+    // 懒加载：只获取需要的版本类型
+    const needReleases = !typeFilter || typeFilter === 'all' || typeFilter === 'release';
+    const needActions = typeFilter === 'action' || typeFilter === 'all';
+
+    // 获取正式版本（仅当需要时）
+    if (needReleases) {
+      try {
+        const result = await getAllTags();
+        usedMirror = result.mirror;
+        
+        versions = result.tags.map(tag => {
+          const isPrerelease = /-(alpha|beta|rc|dev|pre|snapshot)/i.test(tag);
+          return {
+            tag,
+            type: isPrerelease ? 'prerelease' : 'release',
+          } as VersionInfo;
+        });
+
+        // 使用语义化版本排序（最新的在前）
+        versions.sort((a, b) => -compareSemVer(a.tag, b.tag));
+      } catch {
+        // 如果获取 tags 失败，返回空列表而不是抛出错误
+        versions = [];
+      }
+    }
+
+    // 获取 Action Artifacts（仅当需要时）
+    if (needActions) {
+      try {
+        const artifacts = await getLatestActionArtifacts('NapNeko', 'NapCatQQ', 'build.yml', 'main');
+
+        // 根据当前工作环境自动过滤对应的 artifact 类型
+        const isFramework = WebUiDataRuntime.getWorkingEnv() === NapCatCoreWorkingEnv.Framework;
+        const targetArtifactName = isFramework ? 'NapCat.Framework' : 'NapCat.Shell';
+
+        actionVersions = artifacts
+          .filter(a => a.name === targetArtifactName)
+          .map(a => ({
+            tag: `action-${a.id}`,
+            type: 'action' as const,
+            artifactId: a.id,
+            artifactName: a.name,
+            createdAt: a.created_at,
+            expiresAt: a.expires_at,
+            size: a.size_in_bytes,
+            workflowRunId: a.workflow_run_id,
+            headSha: a.head_sha,
+          }));
+      } catch {
+        // 获取失败时返回空列表
+        actionVersions = [];
+      }
+    }
+
+    // 合并版本列表（action 在最前面）
+    let allVersions = [...actionVersions, ...versions];
+
+    // 搜索过滤
+    if (searchQuery) {
+      allVersions = allVersions.filter(v => {
+        const tagMatch = v.tag.toLowerCase().includes(searchQuery);
+        const nameMatch = v.artifactName?.toLowerCase().includes(searchQuery);
+        return tagMatch || nameMatch;
+      });
+    }
+
+    // 分页
+    const total = allVersions.length;
+    const totalPages = Math.ceil(total / pageSize);
+    const start = (page - 1) * pageSize;
+    const end = start + pageSize;
+    const paginatedVersions = allVersions.slice(start, end);
+
+    sendSuccess(res, {
+      versions: paginatedVersions,
+      pagination: {
+        page,
+        pageSize,
+        total,
+        totalPages,
+      },
+      mirror: usedMirror
+    });
+  } catch (error) {
+    res.status(500).json({ error: 'Failed to fetch releases' });
+  }
+};
+
 export const QQVersionHandler: RequestHandler = (_, res) => {
   const data = WebUiDataRuntime.getQQVersion();
   sendSuccess(res, data);

packages/napcat-webui-backend/src/api/Debug.ts

@@ -0,0 +1,406 @@
+import { Router, Request, Response } from 'express';
+import { WebSocket, WebSocketServer } from 'ws';
+import { sendError, sendSuccess } from '@/napcat-webui-backend/src/utils/response';
+import { WebUiDataRuntime } from '@/napcat-webui-backend/src/helper/Data';
+import { IncomingMessage } from 'http';
+import { OB11Response } from '@/napcat-onebot/action/OneBotAction';
+import { ActionName } from '@/napcat-onebot/action/router';
+import { OB11LifeCycleEvent, LifeCycleSubType } from '@/napcat-onebot/event/meta/OB11LifeCycleEvent';
+
+const router = Router();
+const DEFAULT_ADAPTER_NAME = 'debug-primary';
+
+/**
+ * 统一的调试适配器
+ * 用于注入到 OneBot NetworkManager，接收所有事件并转发给 WebSocket 客户端
+ */
+class DebugAdapter {
+  name: string;
+  isEnable: boolean = true;
+  // 安全令牌
+  readonly token: string;
+
+  // 添加 config 属性，模拟 PluginConfig 结构
+  config: {
+    enable: boolean;
+    name: string;
+    messagePostFormat?: string;
+    reportSelfMessage?: boolean;
+    debug?: boolean;
+    token?: string;
+    heartInterval?: number;
+  };
+  wsClients: Set<WebSocket> = new Set();
+  lastActivityTime: number = Date.now();
+  inactivityTimer: NodeJS.Timeout | null = null;
+  readonly INACTIVITY_TIMEOUT = 5 * 60 * 1000; // 5分钟不活跃
+
+  constructor (sessionId: string) {
+    this.name = `debug-${sessionId}`;
+    // 生成简单的随机 token
+    this.token = Math.random().toString(36).substring(2) + Math.random().toString(36).substring(2);
+
+    this.config = {
+      enable: true,
+      name: this.name,
+      messagePostFormat: 'array',
+      reportSelfMessage: true,
+      debug: true,
+      token: this.token,
+      heartInterval: 30000
+    };
+    this.startInactivityCheck();
+  }
+
+  // 实现 IOB11NetworkAdapter 接口所需的抽象方法
+  async open (): Promise<void> { }
+  async close (): Promise<void> { this.cleanup(); }
+  async reload (_config: any): Promise<any> { return 0; }
+
+  /**
+   * OneBot 事件回调 - 转发给所有 WebSocket 客户端 (原始流)
+   */
+  async onEvent (event: any) {
+    this.updateActivity();
+
+    const payload = JSON.stringify(event);
+
+    if (this.wsClients.size === 0) {
+      return;
+    }
+
+    this.wsClients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        try {
+          client.send(payload);
+        } catch (error) {
+          console.error('[Debug] 发送事件到 WebSocket 失败:', error);
+        }
+      }
+    });
+  }
+
+  /**
+   * 调用 OneBot API (HTTP 接口使用)
+   */
+  async callApi (actionName: string, params: any): Promise<any> {
+    this.updateActivity();
+
+    const oneBotContext = WebUiDataRuntime.getOneBotContext();
+    if (!oneBotContext) {
+      throw new Error('OneBot 未初始化');
+    }
+
+    const action = oneBotContext.actions.get(actionName);
+    if (!action) {
+      throw new Error(`不支持的 API: ${actionName}`);
+    }
+
+    return await action.handle(params, this.name, {
+      name: this.name,
+      enable: true,
+      messagePostFormat: 'array',
+      reportSelfMessage: true,
+      debug: true,
+    });
+  }
+
+  /**
+   * 处理 WebSocket 消息 (OneBot 标准)
+   */
+  async handleWsMessage (ws: WebSocket, message: string | Buffer) {
+    this.updateActivity();
+    let receiveData: { action: typeof ActionName[keyof typeof ActionName], params?: any, echo?: any; } = { action: ActionName.Unknown, params: {} };
+    let echo;
+
+    try {
+      receiveData = JSON.parse(message.toString());
+      echo = receiveData.echo;
+    } catch {
+      this.sendWsResponse(ws, OB11Response.error('json解析失败,请检查数据格式', 1400, echo));
+      return;
+    }
+
+    receiveData.params = (receiveData?.params) ? receiveData.params : {};
+
+    // 兼容 WebUI 之前可能的一些非标准格式 (如果用户是旧前端)
+    // 但既然用户说要"原始流"，我们优先支持标准格式
+
+    const oneBotContext = WebUiDataRuntime.getOneBotContext();
+    if (!oneBotContext) {
+      this.sendWsResponse(ws, OB11Response.error('OneBot 未初始化', 1404, echo));
+      return;
+    }
+
+    const action = oneBotContext.actions.get(receiveData.action as any);
+    if (!action) {
+      this.sendWsResponse(ws, OB11Response.error('不支持的API ' + receiveData.action, 1404, echo));
+      return;
+    }
+
+    try {
+      const retdata = await action.websocketHandle(receiveData.params, echo ?? '', this.name, this.config, {
+        send: async (data: object) => {
+          this.sendWsResponse(ws, OB11Response.ok(data, echo ?? '', true));
+        },
+      });
+      this.sendWsResponse(ws, retdata);
+    } catch (e: any) {
+      this.sendWsResponse(ws, OB11Response.error(e.message || '内部错误', 1200, echo));
+    }
+  }
+
+  sendWsResponse (ws: WebSocket, data: any) {
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify(data));
+    }
+  }
+
+  /**
+   * 添加 WebSocket 客户端
+   */
+  addWsClient (ws: WebSocket) {
+    this.wsClients.add(ws);
+    this.updateActivity();
+
+    // 发送生命周期事件 (Connect)
+    const oneBotContext = WebUiDataRuntime.getOneBotContext();
+    if (oneBotContext && oneBotContext.core) {
+      try {
+        const event = new OB11LifeCycleEvent(oneBotContext.core, LifeCycleSubType.CONNECT);
+        ws.send(JSON.stringify(event));
+      } catch (e) {
+        console.error('[Debug] 发送生命周期事件失败', e);
+      }
+    }
+  }
+
+  /**
+   * 移除 WebSocket 客户端
+   */
+  removeWsClient (ws: WebSocket) {
+    this.wsClients.delete(ws);
+  }
+
+  updateActivity () {
+    this.lastActivityTime = Date.now();
+  }
+
+  startInactivityCheck () {
+    this.inactivityTimer = setInterval(() => {
+      const inactive = Date.now() - this.lastActivityTime;
+      // 如果没有 WebSocket 连接且超时，则自动清理
+      if (inactive > this.INACTIVITY_TIMEOUT && this.wsClients.size === 0) {
+        console.log(`[Debug] Adapter ${this.name} 不活跃，自动关闭`);
+        this.cleanup();
+      }
+    }, 30000);
+  }
+
+  cleanup () {
+    if (this.inactivityTimer) {
+      clearInterval(this.inactivityTimer);
+      this.inactivityTimer = null;
+    }
+
+    // 关闭所有 WebSocket 连接
+    this.wsClients.forEach((client) => {
+      try {
+        client.close();
+      } catch (error) {
+        // ignore
+      }
+    });
+    this.wsClients.clear();
+
+    // 从 OneBot NetworkManager 移除
+    const oneBotContext = WebUiDataRuntime.getOneBotContext();
+    if (oneBotContext) {
+      oneBotContext.networkManager.adapters.delete(this.name);
+    }
+
+    // 从管理器中移除
+    debugAdapterManager.removeAdapter(this.name);
+  }
+
+  /**
+   * 验证 Token
+   */
+  validateToken (inputToken: string): boolean {
+    return this.token === inputToken;
+  }
+}
+
+/**
+ * 调试适配器管理器（单例管理）
+ */
+class DebugAdapterManager {
+  private currentAdapter: DebugAdapter | null = null;
+
+  getOrCreateAdapter (): DebugAdapter {
+    // 如果已存在且活跃，直接返回
+    if (this.currentAdapter) {
+      this.currentAdapter.updateActivity();
+      return this.currentAdapter;
+    }
+
+    // 创建新实例
+    const adapter = new DebugAdapter('primary');
+    this.currentAdapter = adapter;
+
+    // 注册到 OneBot NetworkManager
+    const oneBotContext = WebUiDataRuntime.getOneBotContext();
+    if (oneBotContext) {
+      oneBotContext.networkManager.adapters.set(adapter.name, adapter as any);
+    } else {
+      console.warn('[Debug] OneBot 未初始化，无法注册适配器');
+    }
+
+    return adapter;
+  }
+
+  getAdapter (name: string): DebugAdapter | undefined {
+    if (this.currentAdapter && this.currentAdapter.name === name) {
+      return this.currentAdapter;
+    }
+    return undefined;
+  }
+
+  removeAdapter (name: string) {
+    if (this.currentAdapter && this.currentAdapter.name === name) {
+      this.currentAdapter = null;
+    }
+  }
+}
+
+const debugAdapterManager = new DebugAdapterManager();
+
+/**
+ * 获取或创建调试会话
+ */
+router.post('/create', async (_req: Request, res: Response) => {
+  try {
+    const adapter = debugAdapterManager.getOrCreateAdapter();
+    sendSuccess(res, {
+      adapterName: adapter.name,
+      token: adapter.token,
+      message: '调试适配器已就绪',
+    });
+  } catch (error: any) {
+    sendError(res, error.message);
+  }
+});
+
+/**
+ * HTTP 调用 OneBot API (支持默认 adapter)
+ */
+const handleCallApi = async (req: Request, res: Response) => {
+  try {
+    let adapterName = req.params['adapterName'] || req.body.adapterName || DEFAULT_ADAPTER_NAME;
+
+    let adapter = debugAdapterManager.getAdapter(adapterName);
+
+    // 如果是默认 adapter 且不存在，尝试创建
+    if (!adapter && adapterName === DEFAULT_ADAPTER_NAME) {
+      adapter = debugAdapterManager.getOrCreateAdapter();
+    }
+
+    if (!adapter) {
+      return sendError(res, '调试适配器不存在');
+    }
+
+    const { action, params } = req.body;
+    const result = await adapter.callApi(action, params || {});
+    sendSuccess(res, result);
+  } catch (error: any) {
+    sendError(res, error.message);
+  }
+};
+
+router.post('/call/:adapterName', handleCallApi);
+router.post('/call', handleCallApi);
+
+/**
+ * 关闭调试适配器
+ */
+router.post('/close/:adapterName', async (req: Request, res: Response) => {
+  try {
+    const { adapterName } = req.params;
+    if (!adapterName) {
+      return sendError(res, '缺少 adapterName 参数');
+    }
+    debugAdapterManager.removeAdapter(adapterName);
+    sendSuccess(res, { message: '调试适配器已关闭' });
+  } catch (error: any) {
+    sendError(res, error.message);
+  }
+});
+
+/**
+ * WebSocket 连接处理
+ * 路径: /api/Debug/ws?adapterName=xxx&token=xxx
+ */
+export function handleDebugWebSocket (request: IncomingMessage, socket: any, head: any) {
+  const url = new URL(request.url || '', `http://${request.headers.host}`);
+  let adapterName = url.searchParams.get('adapterName');
+  const token = url.searchParams.get('token') || url.searchParams.get('access_token');
+
+  // 默认 adapterName
+  if (!adapterName) {
+    adapterName = DEFAULT_ADAPTER_NAME;
+  }
+
+  // Debug session should provide token
+  if (!token) {
+    console.log('[Debug] WebSocket 连接被拒绝: 缺少 Token');
+    socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n');
+    socket.destroy();
+    return;
+  }
+
+  let adapter = debugAdapterManager.getAdapter(adapterName);
+
+  // 如果是默认 adapter 且不存在，尝试创建
+  if (!adapter && adapterName === DEFAULT_ADAPTER_NAME) {
+    adapter = debugAdapterManager.getOrCreateAdapter();
+  }
+
+  if (!adapter) {
+    console.log('[Debug] WebSocket 连接被拒绝: 适配器不存在');
+    socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+    socket.destroy();
+    return;
+  }
+
+  if (!adapter.validateToken(token)) {
+    console.log('[Debug] WebSocket 连接被拒绝: Token 无效');
+    socket.write('HTTP/1.1 403 Forbidden\r\n\r\n');
+    socket.destroy();
+    return;
+  }
+
+  // 创建 WebSocket 服务器
+  const wsServer = new WebSocketServer({ noServer: true });
+
+  wsServer.handleUpgrade(request, socket, head, (ws) => {
+    adapter.addWsClient(ws);
+
+    ws.on('message', async (data) => {
+      try {
+        await adapter.handleWsMessage(ws, data as any);
+      } catch (error: any) {
+        console.error('[Debug] handleWsMessage error', error);
+      }
+    });
+
+    ws.on('close', () => {
+      adapter.removeWsClient(ws);
+    });
+
+    ws.on('error', () => {
+      adapter.removeWsClient(ws);
+    });
+  });
+}
+
+export default router;

packages/napcat-webui-backend/src/api/File.ts

@@ -640,10 +640,10 @@ export const UploadWebUIFontHandler: RequestHandler = async (req, res) => {
 // 删除WebUI字体文件处理方法
 export const DeleteWebUIFontHandler: RequestHandler = async (_req, res) => {
   try {
-    const fontPath = WebUiConfig.GetWebUIFontPath();
+    const fontPath = await WebUiConfig.GetWebUIFontPath();
     const exists = await WebUiConfig.CheckWebUIFontExist();
 
-    if (!exists) {
+    if (!exists || !fontPath) {
       return sendSuccess(res, true);
     }
 

packages/napcat-webui-backend/src/api/Plugin.ts

@@ -0,0 +1,225 @@
+import { RequestHandler } from 'express';
+import { WebUiDataRuntime } from '@/napcat-webui-backend/src/helper/Data';
+import { sendError, sendSuccess } from '@/napcat-webui-backend/src/utils/response';
+import { NapCatOneBot11Adapter } from '@/napcat-onebot/index';
+import { OB11PluginMangerAdapter } from '@/napcat-onebot/network/plugin-manger';
+import path from 'path';
+import fs from 'fs';
+
+// Helper to get the plugin manager adapter
+const getPluginManager = (): OB11PluginMangerAdapter | null => {
+  const ob11 = WebUiDataRuntime.getOneBotContext() as NapCatOneBot11Adapter;
+  if (!ob11) return null;
+  return ob11.networkManager.findSomeAdapter('plugin_manager') as OB11PluginMangerAdapter;
+};
+
+export const GetPluginListHandler: RequestHandler = async (_req, res) => {
+  const pluginManager = getPluginManager();
+  if (!pluginManager) {
+    return sendError(res, 'Plugin Manager not found');
+  }
+
+  // 辅助函数：根据文件名/路径生成唯一ID（作为配置键）
+  const getPluginId = (fsName: string, isFile: boolean): string => {
+    if (isFile) {
+      return path.parse(fsName).name;
+    }
+    return fsName;
+  };
+
+  const loadedPlugins = pluginManager.getLoadedPlugins();
+  const loadedPluginMap = new Map<string, any>(); // Map ID -> Loaded Info
+
+  // 1. 整理已加载的插件
+  for (const p of loadedPlugins) {
+    // 计算 ID：需要回溯到加载时的入口信息
+    // 对于已加载的插件，我们通过判断 pluginPath 是否等于根 pluginPath 来判断它是单文件还是目录
+    const isFilePlugin = p.pluginPath === pluginManager.getPluginPath();
+    const fsName = isFilePlugin ? path.basename(p.entryPath) : path.basename(p.pluginPath);
+    const id = getPluginId(fsName, isFilePlugin);
+
+    loadedPluginMap.set(id, {
+      name: p.packageJson?.name || p.name, // 优先使用 package.json 的 name
+      id: id,
+      version: p.version || '0.0.0',
+      description: p.packageJson?.description || '',
+      author: p.packageJson?.author || '',
+      status: 'active',
+      filename: fsName, // 真实文件/目录名
+      loadedName: p.name // 运行时注册的名称，用于重载/卸载
+    });
+  }
+
+  const pluginPath = pluginManager.getPluginPath();
+  const pluginConfig = pluginManager.getPluginConfig();
+  const allPlugins: any[] = [];
+
+  // 2. 扫描文件系统，合并状态
+  if (fs.existsSync(pluginPath)) {
+    const items = fs.readdirSync(pluginPath, { withFileTypes: true });
+
+    for (const item of items) {
+      let id = '';
+
+      if (item.isFile()) {
+        if (!['.js', '.mjs'].includes(path.extname(item.name))) continue;
+        id = getPluginId(item.name, true);
+      } else if (item.isDirectory()) {
+        id = getPluginId(item.name, false);
+      } else {
+        continue;
+      }
+
+      const isActiveConfig = pluginConfig[id] !== false; // 默认为 true
+
+      if (loadedPluginMap.has(id)) {
+        // 已加载，使用加载的信息
+        const loadedInfo = loadedPluginMap.get(id);
+        allPlugins.push(loadedInfo);
+      } else {
+        // 未加载 (可能是被禁用，或者加载失败，或者新增未运行)
+        let version = '0.0.0';
+        let description = '';
+        let author = '';
+        // 默认显示名称为 ID (文件名/目录名)
+        let name = id;
+
+        try {
+          // 尝试读取 package.json 获取信息
+          if (item.isDirectory()) {
+            const packageJsonPath = path.join(pluginPath, item.name, 'package.json');
+            if (fs.existsSync(packageJsonPath)) {
+              const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+              version = pkg.version || version;
+              description = pkg.description || description;
+              author = pkg.author || author;
+              // 如果 package.json 有 name，优先使用
+              name = pkg.name || name;
+            }
+          }
+        } catch (e) { }
+
+        allPlugins.push({
+          name: name,
+          id: id,
+          version,
+          description,
+          author,
+          // 如果配置是 false，则为 disabled；否则是 stopped (应启动但未启动)
+          status: isActiveConfig ? 'stopped' : 'disabled',
+          filename: item.name
+        });
+      }
+    }
+  }
+
+  return sendSuccess(res, allPlugins);
+};
+
+export const ReloadPluginHandler: RequestHandler = async (req, res) => {
+  const { name } = req.body;
+  // Note: we should probably accept ID or Name. But ReloadPlugin uses valid loaded name.
+  // Let's stick to name for now, but be aware of ambiguity.
+  if (!name) return sendError(res, 'Plugin Name is required');
+
+  const pluginManager = getPluginManager();
+  if (!pluginManager) {
+    return sendError(res, 'Plugin Manager not found');
+  }
+
+  const success = await pluginManager.reloadPlugin(name);
+  if (success) {
+    return sendSuccess(res, { message: 'Reloaded successfully' });
+  } else {
+    return sendError(res, 'Failed to reload plugin');
+  }
+};
+
+export const SetPluginStatusHandler: RequestHandler = async (req, res) => {
+  const { enable, filename } = req.body;
+  // We Use filename / id to control config
+  // Front-end should pass the 'filename' or 'id' as the key identifier
+
+  if (!filename) return sendError(res, 'Plugin Filename/ID is required');
+
+  const pluginManager = getPluginManager();
+  if (!pluginManager) {
+    return sendError(res, 'Plugin Manager not found');
+  }
+
+  // Calculate ID from filename (remove ext if file)
+  // Or just use the logic consistent with loadPlugins
+  let id = filename;
+  // If it has extension .js/.mjs, remove it to get the ID used in config
+  if (filename.endsWith('.js') || filename.endsWith('.mjs')) {
+    id = path.parse(filename).name;
+  }
+
+  try {
+    pluginManager.setPluginStatus(id, enable);
+
+    // If enabling, trigger load
+    if (enable) {
+      const pluginPath = pluginManager.getPluginPath();
+      const fullPath = path.join(pluginPath, filename);
+
+      if (fs.statSync(fullPath).isDirectory()) {
+        await pluginManager.loadDirectoryPlugin(filename);
+      } else {
+        await pluginManager.loadFilePlugin(filename);
+      }
+    } else {
+      // Disabling is handled inside setPluginStatus usually if implemented,
+      // OR we can explicitly unload here using the loaded name.
+      // The Manager's setPluginStatus implementation (if added) might logic this out.
+      // But our current Manager implementation just saves config.
+      // Wait, I updated Manager to try to unload.
+      // Let's rely on Manager's setPluginStatus or do it here?
+      // I implemented a basic unload loop in Manager.setPluginStatus.
+    }
+
+    return sendSuccess(res, { message: 'Status updated successfully' });
+  } catch (e: any) {
+    return sendError(res, 'Failed to update status: ' + e.message);
+  }
+};
+
+export const UninstallPluginHandler: RequestHandler = async (req, res) => {
+  const { name, filename } = req.body;
+  // If it's loaded, we use name. If it's disabled, we might use filename.
+
+  const pluginManager = getPluginManager();
+  if (!pluginManager) {
+    return sendError(res, 'Plugin Manager not found');
+  }
+
+  // Check if loaded
+  const plugin = pluginManager.getPluginInfo(name);
+  let fsPath = '';
+
+  if (plugin) {
+    // Active plugin
+    await pluginManager.unregisterPlugin(name);
+    if (plugin.pluginPath === pluginManager.getPluginPath()) {
+      fsPath = plugin.entryPath;
+    } else {
+      fsPath = plugin.pluginPath;
+    }
+  } else {
+    // Disabled or not loaded
+    if (filename) {
+      fsPath = path.join(pluginManager.getPluginPath(), filename);
+    } else {
+      return sendError(res, 'Plugin not found, provide filename if disabled');
+    }
+  }
+
+  try {
+    if (fs.existsSync(fsPath)) {
+      fs.rmSync(fsPath, { recursive: true, force: true });
+    }
+    return sendSuccess(res, { message: 'Uninstalled successfully' });
+  } catch (e: any) {
+    return sendError(res, 'Failed to uninstall: ' + e.message);
+  }
+};

packages/napcat-webui-backend/src/api/Process.ts

@@ -0,0 +1,21 @@
+import type { Request, Response } from 'express';
+import { WebUiDataRuntime } from '../helper/Data';
+import { sendError, sendSuccess } from '../utils/response';
+
+/**
+ * 重启进程处理器
+ * POST /api/Process/Restart
+ */
+export async function RestartProcessHandler (_req: Request, res: Response) {
+  try {
+    const result = await WebUiDataRuntime.requestRestartProcess();
+
+    if (result.result) {
+      return sendSuccess(res, { message: result.message || '进程重启请求已发送' });
+    } else {
+      return sendError(res, result.message || '进程重启失败');
+    }
+  } catch (e) {
+    return sendError(res, '重启进程时发生错误: ' + (e as Error).message);
+  }
+}