Compare commits

...
7 Commits
Author SHA1 Message Date
手瓜一十雪 93efce86ca feat: re
Release Tag / validate-version (push) Canceled after 0s
Release Tag / trigger-release (push) Canceled after 0s
2026-06-20 12:41:32 +08:00
Ryokuryuneko 091c012427 feat(webui): 添加双重登录验证(2FA)功能 (#1920)
* feat(webui): 添加双重登录验证(2FA)功能

* fix: 修复 store.delete 类型错误,添加完整项目文件

* feat(webui): 添加双重登录验证(2FA)功能

- 后端:实现 TOTP 验证码生成和验证
- 后端:添加 enable2FA 和 totpSecret 配置项
- 后端:登录处理器支持 2FA 验证
- 前端:添加 2FA 登录流程和配置页面

* feat(webui): 添加双重登录验证(2FA)功能

- 后端:实现 TOTP 验证码生成和验证 (TotpHelper.ts)
- 后端:添加 enable2FA 和 totpSecret 配置项 (config.ts)
- 后端:登录处理器支持 2FA 验证,添加 2FA 管理 API (Auth.ts)
- 后端:注册 2FA 相关路由 (auth.ts)
- 前端:登录页面添加 2FA 验证步骤 (web_login.tsx)
- 前端:添加 2FA 相关 API 调用方法 (webui_manager.ts)
- 前端:添加 2FA 配置页面 (webui.tsx)

* fix: 更新 AuthResponse 类型定义以支持 2FA

* fix: 修复 setLocalToken 类型错误

* fix: 修复 TotpHelper.ts 类型错误

* fix: address PR review feedback

- Remove database files from tracking
- Use local QRCodeSVG instead of third-party API
- Remove unused verify2FACode method
- Remove IP-based challenge storage (password already validated)
- Require TOTP code to disable 2FA
- Remove duplicate loginWithTokenAndTotp method
- Remove unused generateTotp method
- Use consistent English error messages

* fix: remove unused store import

* chore: translate 2FA UI to Chinese
2026-06-20 09:56:54 +08:00
tzhd427 8a3faf64f9 对WebUI布局的修改 (#1906)
* 把“系统设置-修改密码”移动到“系统设置-WebUI配置”中

* 修正语法错误

* 把修改密码移动到上方
2026-06-17 01:01:10 +08:00
cc10143 fbd70bbb04 fix: reset QQLoginStatus on KickedOffLine to prevent WebUI re-login block (#1896)
When QQ kicks the bot offline, the WebUI incorrectly shows the account as still
logged in, blocking users from re-login via QR code or password until NapCat is
restarted.

Root cause: The KickedOffLine event handlers in both the shell (base.ts) and
framework (napcat.ts) only set the error message without resetting
QQLoginStatus. The QQGetQRcodeHandler and other login endpoints check
getQQLoginStatus() and reject all re-login attempts when it remains true.

Fix: Set QQLoginStatus to false in both event handlers, ensuring the WebUI
state syncs with the actual account status when kicked offline.

Two changes:
- napcat-shell/base.ts: add setQQLoginStatus(false) before setQQLoginError()
- napcat-framework/napcat.ts: register a KickedOffLine listener that resets
  the login status (the framework previously had no KickedOffLine listener)

Fixes: #508, #1818
2026-06-11 14:43:16 +08:00
MliKiowa c405b6d0a4 docs: 社区进一步限制
Signed-off-by: MliKiowa <nanaeonn@outlook.com>
2026-06-09 23:45:19 +08:00
手瓜一十雪 3a4b335062 feat
Release Tag / validate-version (push) Canceled after 0s
Release Tag / trigger-release (push) Canceled after 0s
2026-06-08 20:01:03 +08:00
Qiao 9aa11fd7c4 fix: 校验群名片设置结果 (#1880) 2026-06-04 23:56:45 +08:00
20 changed files with 1002 additions and 1092 deletions

No files matched your search

+19
View File
@@ -0,0 +1,19 @@
{
"permissions": {
"allow": [
"Bash(tasklist)",
"Bash(sort -rk5)",
"Bash(powershell \"Get-Process | Sort-Object CPU -Descending | Select-Object -First 15 Name,CPU,Id,WorkingSet | Format-Table -AutoSize\")",
"Bash(powershell *)",
"Bash(where ssh *)",
"Bash(where plink *)",
"Bash(where sshpass *)",
"Bash(echo \"exit=$?\")",
"Bash(python -c \"import paramiko; print\\('paramiko OK'\\)\")",
"Bash(pnpm --filter napcat-common run typecheck)",
"Bash(pnpm --filter napcat-core run typecheck)",
"Bash(pnpm --filter napcat-onebot run typecheck)",
"Bash(git *)"
]
}
}
+1 -1
View File
@@ -58,7 +58,7 @@ _Modern protocol-side framework implemented based on NTQQ._
> QQ群因为特殊原因需要入群密钥,请在webui关于页面获取,仅最新的100个版本以内有效。
下面的QQ Group 无需密钥,随时清理不活跃人员和Bot,仅500人容量。
社区相关日后会进一步加强审核,并严格限制一定时间的入群人数,请具备一定编程基础和问题解决能力再申请入群。
[困困猫猫的高中](https://qm.qq.com/q/14aUVclRUA)
+5
View File
@@ -195,6 +195,11 @@ export async function NCoreInitFramework (
if (oneBotAdapter) {
WebUiDataRuntime.setOneBotContext(oneBotAdapter);
}
// 监听下线通知并同步到 WebUI(兜底保障,防止 WebUI 状态不同步)
loaderObject.core.event.on('KickedOffLine', () => {
WebUiDataRuntime.setQQLoginStatus(false);
});
}
function registerWebUiLoginCallbacks (
@@ -1,6 +1,7 @@
import { OneBotAction } from '@/napcat-onebot/action/OneBotAction';
import { ActionName } from '@/napcat-onebot/action/router';
import { Static, Type } from '@sinclair/typebox';
import { sleep } from '@/napcat-common/src/helper';
import { GroupActionsExamples } from '../example/GroupActionsExamples';
@@ -27,8 +28,24 @@ export default class SetGroupCard extends OneBotAction<PayloadType, ReturnType>
override returnExample = GroupActionsExamples.SetGroupCard.response;
async _handle (payload: PayloadType): Promise<null> {
const member = await this.core.apis.GroupApi.getGroupMember(payload.group_id.toString(), payload.user_id.toString());
if (member) await this.core.apis.GroupApi.setMemberCard(payload.group_id.toString(), member.uid, payload.card || '');
return null;
const groupId = payload.group_id.toString();
const userId = payload.user_id.toString();
const card = payload.card || '';
const member = await this.core.apis.GroupApi.getGroupMember(groupId, userId);
if (!member) {
throw new Error(`群(${groupId})成员${userId}不存在`);
}
await this.core.apis.GroupApi.setMemberCard(groupId, member.uid, card);
for (let i = 0; i < 3; i++) {
await sleep(1000);
const updatedMember = await this.core.apis.GroupApi.refreshGroupMemberCachePartial(groupId, member.uid);
if (updatedMember?.cardName === card) {
return null;
}
}
throw new Error('设置群名片未生效');
}
}
-4
View File
@@ -157,10 +157,6 @@ export class NapCatOneBot11Adapter {
// 创建NetWork服务
// 注册Plugin 如果需要基于NapCat进行快速开发
// this.networkManager.registerAdapter(
// new OB11PluginAdapter('myPlugin', this.core, this,this.actions)
// );
// 检查插件目录是否存在,不存在则不加载插件管理器
if (existsSync(this.context.pathWrapper.pluginPath)) {
this.context.logger.log('[Plugins] 插件目录存在,开始加载插件');
@@ -1,378 +0,0 @@
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 { IOB11NetworkAdapter } from '@/napcat-onebot/network/adapter';
import fs from 'fs';
import path from 'path';
export interface PluginPackageJson {
name?: string;
plugin?: string;
version?: string;
main?: string;
}
export interface PluginModule<T extends OB11EmitEventContent = OB11EmitEventContent> {
plugin_init: (core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap, instance: OB11PluginAdapter) => void | Promise<void>;
plugin_onmessage?: (adapter: string, core: NapCatCore, obCtx: NapCatOneBot11Adapter, event: OB11Message, actions: ActionMap, instance: OB11PluginAdapter) => void | Promise<void>;
plugin_onevent?: (adapter: string, core: NapCatCore, obCtx: NapCatOneBot11Adapter, event: T, actions: ActionMap, instance: OB11PluginAdapter) => void | Promise<void>;
plugin_cleanup?: (core: NapCatCore, obContext: NapCatOneBot11Adapter, actions: ActionMap, instance: OB11PluginAdapter) => void | Promise<void>;
}
export interface LoadedPlugin {
name: string;
version?: string;
pluginPath: string;
entryPath: string;
packageJson?: PluginPackageJson;
module: PluginModule;
}
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
) {
const config = {
name,
messagePostFormat: 'array',
reportSelfMessage: true,
enable: true,
debug: true,
};
super(name, config, core, obContext, actions);
this.pluginPath = this.core.context.pathWrapper.pluginPath;
}
/**
* 扫描并加载插件
*/
private async loadPlugins (): Promise<void> {
try {
// 确保插件目录存在
if (!fs.existsSync(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 });
// 扫描文件和目录
for (const item of items) {
if (item.isFile()) {
// 处理单文件插件
await this.loadFilePlugin(item.name);
} else if (item.isDirectory()) {
// 处理目录插件
await this.loadDirectoryPlugin(item.name);
}
}
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> {
// 只处理支持的文件类型
if (!this.isSupportedFile(filename)) {
return;
}
const filePath = path.join(this.pluginPath, filename);
const pluginName = path.parse(filename).name;
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)`);
return;
}
const plugin: LoadedPlugin = {
name: pluginName,
pluginPath: this.pluginPath,
entryPath: filePath,
module,
};
await this.registerPlugin(plugin);
} catch (error) {
this.logger.logError(`[Plugin Adapter] Error loading file plugin ${filename}:`, error);
}
}
/**
* 加载目录插件
*/
private async loadDirectoryPlugin (dirname: string): Promise<void> {
const pluginDir = path.join(this.pluginPath, dirname);
try {
// 尝试读取 package.json
let packageJson: PluginPackageJson | undefined;
const packageJsonPath = path.join(pluginDir, 'package.json');
if (fs.existsSync(packageJsonPath)) {
try {
const packageContent = fs.readFileSync(packageJsonPath, 'utf-8');
packageJson = JSON.parse(packageContent);
} catch (error) {
this.logger.logWarn(`[Plugin Adapter] Invalid package.json in ${dirname}:`, error);
}
}
// 确定入口文件
const entryFile = this.findEntryFile(pluginDir, packageJson);
if (!entryFile) {
this.logger.logWarn(`[Plugin Adapter] No valid entry file found for plugin directory: ${dirname}`);
return;
}
const entryPath = path.join(pluginDir, entryFile);
const module = await this.importModule(entryPath);
if (!this.isValidPluginModule(module)) {
this.logger.logWarn(`[Plugin Adapter] Directory ${dirname} does not contain a valid plugin`);
return;
}
const plugin: LoadedPlugin = {
name: packageJson?.name || dirname,
version: packageJson?.version,
pluginPath: pluginDir,
entryPath,
packageJson,
module,
};
await this.registerPlugin(plugin);
} catch (error) {
this.logger.logError(`[Plugin Adapter] Error loading directory plugin ${dirname}:`, error);
}
}
/**
* 查找插件目录的入口文件
*/
private findEntryFile (pluginDir: string, packageJson?: PluginPackageJson): string | null {
// 优先级:package.json main > 默认文件名
const possibleEntries = [
packageJson?.main,
'index.mjs',
'index.js',
'main.mjs',
'main.js',
].filter(Boolean) as string[];
for (const entry of possibleEntries) {
const entryPath = path.join(pluginDir, entry);
if (fs.existsSync(entryPath) && fs.statSync(entryPath).isFile()) {
return entry;
}
}
return null;
}
/**
* 检查是否为支持的文件类型
*/
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);
}
/**
* 检查模块是否为有效的插件模块
*/
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...`);
return;
}
this.loadedPlugins.set(plugin.name, plugin);
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);
this.logger.log(`[Plugin Adapter] Initialized plugin: ${plugin.name}`);
} catch (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) {
return;
}
// 调用插件清理方法
if (typeof plugin.module.plugin_cleanup === 'function') {
try {
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.loadedPlugins.delete(pluginName);
this.logger.log(`[Plugin Adapter] Unloaded plugin: ${pluginName}`);
}
async onEvent<T extends OB11EmitEventContent> (event: T) {
if (!this.isEnable) {
return;
}
// 遍历所有已加载的插件,调用它们的事件处理方法
for (const [, plugin] of this.loadedPlugins) {
this.callPluginEventHandler(plugin, event);
}
}
/**
* 调用插件的事件处理方法
*/
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);
}
// 如果是消息事件并且插件有 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);
}
} catch (error) {
this.logger.logError(`[Plugin Adapter] Error calling plugin ${plugin.name} event handler:`, error);
}
}
async open () {
if (this.isEnable) {
return;
}
this.logger.log('[Plugin Adapter] Opening plugin adapter...');
this.isEnable = true;
// 加载所有插件
await this.loadPlugins();
this.logger.log(`[Plugin Adapter] Plugin adapter opened with ${this.loadedPlugins.size} plugins loaded`);
}
async close () {
if (!this.isEnable) {
return;
}
this.logger.log('[Plugin Adapter] Closing plugin adapter...');
this.isEnable = false;
// 卸载所有插件
const pluginNames = Array.from(this.loadedPlugins.keys());
for (const pluginName of pluginNames) {
await this.unloadPlugin(pluginName);
}
this.logger.log('[Plugin Adapter] Plugin adapter closed');
}
async reload () {
this.logger.log('[Plugin Adapter] Reloading plugin adapter...');
// 先关闭然后重新打开
await this.close();
await this.open();
this.logger.log('[Plugin Adapter] Plugin adapter reloaded');
return OB11NetworkReloadType.Normal;
}
/**
* 获取已加载的插件列表
*/
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) {
this.logger.logWarn(`[Plugin Adapter] Plugin ${pluginName} not found`);
return false;
}
try {
// 卸载插件
await this.unloadPlugin(pluginName);
// 重新加载插件
const isDirectory = fs.statSync(plugin.pluginPath).isDirectory() &&
plugin.pluginPath !== this.pluginPath;
if (isDirectory) {
const dirname = path.basename(plugin.pluginPath);
await this.loadDirectoryPlugin(dirname);
} else {
const filename = path.basename(plugin.entryPath);
await this.loadFilePlugin(filename);
}
this.logger.log(`[Plugin Adapter] Plugin ${pluginName} reloaded successfully`);
return true;
} catch (error) {
this.logger.logError(`[Plugin Adapter] Error reloading plugin ${pluginName}:`, error);
return false;
}
}
}
+109 -1
View File
@@ -10,6 +10,31 @@ import {
} from './types';
const require = createRequire(import.meta.url);
/** 允许加载的官方插件 ID 白名单。不在表内的插件一律拒绝加载。 */
const OFFICIAL_PLUGIN_IDS = new Set<string>([
'napcat-plugin-builtin',
'napcat-plugin-cleaner',
'napcat-plugin-ssqq',
'napcat-plugin-qce',
]);
/**
* 敏感词表:插件源码命中(黑灰产 / 支付发卡相关)即拒绝加载。
* 仅作启发式威慑,混淆/编码可绕过,并非唯一防线。
*/
const SENSITIVE_KEYWORDS: string[] = [
'发卡', '卡密', '卡网', '自动发卡', '寄售', '代刷', '刷单', '跑分',
'四件套', '洗钱', '黑产', '灰产', '博彩', '赌博', '菠菜', '涉黄',
'色情', '收款码', '代付', '担保交易', '第三方支付', 'USDT',
];
/** 纳入敏感词检测的源码扩展名 */
const SCAN_EXTS = new Set(['.js', '.mjs', '.cjs', '.ts']);
/** 跳过敏感词扫描的目录名 */
const SCAN_SKIP_DIRS = new Set(['data', 'node_modules', '.git']);
/** 单文件扫描大小上限,避免超大文件拖慢启动 */
const SCAN_MAX_FILE_BYTES = 5 * 1024 * 1024;
/**
* 插件加载器
* 负责扫描、加载和导入插件模块
@@ -121,6 +146,15 @@ export class PluginLoader {
// 获取插件 ID(包名或目录名)
const pluginId = packageJson?.name || dirname;
// 官方白名单 + 敏感词校验:被拒绝的插件视为不可见,
// 不入列表、不加载、更不会被动态导入执行。
// 该检查置于此处统一拦截 scanPlugins 与 rescanPlugin(安装/重载)两条路径。
const rejectReason = this.getRejectReason(pluginId, pluginDir);
if (rejectReason) {
this.logger.logWarn(`[PluginLoader] Rejected ${pluginId} (${dirname}): ${rejectReason}`);
return null;
}
// 确定入口文件
const entryFile = this.findEntryFile(pluginDir, packageJson);
const entryPath = entryFile ? path.join(pluginDir, entryFile) : undefined;
@@ -184,7 +218,12 @@ export class PluginLoader {
].filter(Boolean) as string[];
for (const entry of possibleEntries) {
const entryPath = path.join(pluginDir, entry);
const root = path.resolve(pluginDir);
const entryPath = path.resolve(pluginDir, entry);
// 拒绝 package.json main 指向插件目录之外(防路径穿越)
if (entryPath !== root && !entryPath.startsWith(root + path.sep)) {
continue;
}
if (fs.existsSync(entryPath) && fs.statSync(entryPath).isFile()) {
return entry;
}
@@ -193,6 +232,75 @@ export class PluginLoader {
return null;
}
/** 是否为白名单内的官方插件 */
isOfficialPlugin (pluginId: string): boolean {
return OFFICIAL_PLUGIN_IDS.has(pluginId);
}
/**
* 判断插件是否应被拒绝(非官方 / 命中敏感词)。
* @returns 拒绝原因;通过校验返回 null
*/
private getRejectReason (pluginId: string, pluginDir: string): string | null {
const hit = this.scanSensitiveWords(pluginDir);
if (this.isOfficialPlugin(pluginId)) {
return null;
}
if (hit) {
return `sensitive keyword "${hit}"`;
}
return "not in official plugin whitelist";
}
/**
* 递归扫描插件目录内源码是否命中敏感词(黑灰产 / 支付发卡)。
* @returns 命中的敏感词;未命中返回 null
*/
scanSensitiveWords (pluginDir: string): string | null {
const visit = (dir: string): string | null => {
let items: fs.Dirent[];
try {
items = fs.readdirSync(dir, { withFileTypes: true });
} catch {
return null;
}
for (const item of items) {
if (item.isDirectory()) {
if (SCAN_SKIP_DIRS.has(item.name)) {
continue;
}
const hit = visit(path.join(dir, item.name));
if (hit) {
return hit;
}
continue;
}
if (!item.isFile()) {
continue;
}
if (!SCAN_EXTS.has(path.extname(item.name).toLowerCase())) {
continue;
}
const filePath = path.join(dir, item.name);
try {
if (fs.statSync(filePath).size > SCAN_MAX_FILE_BYTES) {
continue;
}
const content = fs.readFileSync(filePath, 'utf-8');
for (const word of SENSITIVE_KEYWORDS) {
if (content.includes(word)) {
return word;
}
}
} catch {
// 读取失败忽略该文件
}
}
return null;
};
return visit(pluginDir);
}
/**
* 动态导入模块
*/
@@ -1,529 +0,0 @@
import fs from 'fs';
import path from 'path';
import { ActionMap } from '@/napcat-onebot/action';
import { NapCatCore } from 'napcat-core';
import { NapCatOneBot11Adapter, OB11Message } from '@/napcat-onebot/index';
import { OB11EmitEventContent, OB11NetworkReloadType } from '@/napcat-onebot/network/index';
import { IOB11NetworkAdapter } from '@/napcat-onebot/network/adapter';
import { PluginConfig } from '@/napcat-onebot/config/config';
import { NapCatConfig } from './config';
import { PluginLoader } from './loader';
import { PluginRouterRegistryImpl } from './router-registry';
import {
PluginEntry,
PluginLogger,
PluginStatusConfig,
NapCatPluginContext,
IPluginManager,
} from './types';
export class OB11PluginManager extends IOB11NetworkAdapter<PluginConfig> implements IPluginManager {
private readonly pluginPath: string;
private readonly configPath: string;
private readonly loader: PluginLoader;
/** 插件注册表: ID -> 插件条目 */
private plugins: Map<string, PluginEntry> = new Map();
/** 插件路由注册表: pluginId -> PluginRouterRegistry */
private pluginRouters: Map<string, PluginRouterRegistryImpl> = new Map();
declare config: PluginConfig;
public NapCatConfig = NapCatConfig;
override get isActive (): boolean {
return this.isEnable && this.getLoadedPlugins().length > 0;
}
constructor (
name: string,
core: NapCatCore,
obContext: NapCatOneBot11Adapter,
actions: ActionMap
) {
const config = {
name,
messagePostFormat: 'array',
reportSelfMessage: true,
enable: true,
debug: true,
};
super(name, config, core, obContext, actions);
this.pluginPath = this.core.context.pathWrapper.pluginPath;
this.configPath = path.join(this.core.context.pathWrapper.configPath, 'plugins.json');
this.loader = new PluginLoader(this.pluginPath, this.configPath, this.logger);
}
// ==================== 插件状态配置 ====================
public getPluginConfig (): PluginStatusConfig {
return this.loader.loadPluginStatusConfig();
}
private savePluginConfig (config: PluginStatusConfig): void {
this.loader.savePluginStatusConfig(config);
}
// ==================== 插件扫描与加载 ====================
/**
* 扫描并加载所有插件
*/
private async scanAndLoadPlugins (): Promise<void> {
// 扫描所有插件目录
const entries = await this.loader.scanPlugins();
// 清空现有注册表
this.plugins.clear();
// 注册所有插件条目
for (const entry of entries) {
this.plugins.set(entry.id, entry);
}
this.logger.log(`[PluginManager] Scanned ${this.plugins.size} plugins`);
// 加载启用的插件
for (const entry of this.plugins.values()) {
if (entry.enable && entry.runtime.status !== 'error') {
await this.loadPlugin(entry);
}
}
const loadedCount = this.getLoadedPlugins().length;
this.logger.log(`[PluginManager] Loaded ${loadedCount} plugins`);
}
/**
* 加载单个插件
*/
private async loadPlugin (entry: PluginEntry): Promise<boolean> {
if (entry.loaded) {
return true;
}
if (entry.runtime.status === 'error') {
return false;
}
// 加载模块
const module = await this.loader.loadPluginModule(entry);
if (!module) {
return false;
}
// 创建上下文
const context = this.createPluginContext(entry);
// 初始化插件
try {
await module.plugin_init(context);
entry.loaded = true;
entry.runtime = {
status: 'loaded',
module,
context,
};
this.logger.log(`[PluginManager] Initialized plugin: ${entry.id}${entry.version ? ` v${entry.version}` : ''}`);
return true;
} catch (error: any) {
entry.loaded = false;
entry.runtime = {
status: 'error',
error: error.message || 'Initialization failed',
};
this.logger.logError(`[PluginManager] Error initializing plugin ${entry.id}:`, error);
return false;
}
}
/**
* 卸载单个插件
*/
private async unloadPlugin (entry: PluginEntry): Promise<void> {
if (!entry.loaded || entry.runtime.status !== 'loaded') {
return;
}
const { module, context } = entry.runtime;
// 调用清理方法
if (module && context && typeof module.plugin_cleanup === 'function') {
try {
await module.plugin_cleanup(context);
this.logger.log(`[PluginManager] Cleaned up plugin: ${entry.id}`);
} catch (error) {
this.logger.logError(`[PluginManager] Error cleaning up plugin ${entry.id}:`, error);
}
}
// 重置状态
entry.loaded = false;
entry.runtime = {
status: 'unloaded',
};
this.logger.log(`[PluginManager] Unloaded plugin: ${entry.id}`);
}
/**
* 创建插件上下文
*/
private createPluginContext (entry: PluginEntry): NapCatPluginContext {
const dataPath = path.join(this.core.context.pathWrapper.configPath, 'plugins', entry.id);
const configPath = path.join(dataPath, 'config.json');
// 确保插件配置目录存在
if (!fs.existsSync(dataPath)) {
fs.mkdirSync(dataPath, { recursive: true });
}
// 创建插件专用日志器
const pluginPrefix = `[Plugin: ${entry.id}]`;
const coreLogger = this.logger;
const pluginLogger: PluginLogger = {
log: (...args: any[]) => coreLogger.log(pluginPrefix, ...args),
debug: (...args: any[]) => coreLogger.logDebug(pluginPrefix, ...args),
info: (...args: any[]) => coreLogger.log(pluginPrefix, ...args),
warn: (...args: any[]) => coreLogger.logWarn(pluginPrefix, ...args),
error: (...args: any[]) => coreLogger.logError(pluginPrefix, ...args),
};
// 创建或获取插件路由注册器
let router = this.pluginRouters.get(entry.id);
if (!router) {
router = new PluginRouterRegistryImpl(entry.id, entry.pluginPath);
this.pluginRouters.set(entry.id, router);
}
// 创建获取其他插件导出的方法
const getPluginExports = <T = any> (pluginId: string): T | undefined => {
const targetEntry = this.plugins.get(pluginId);
if (!targetEntry || !targetEntry.loaded || targetEntry.runtime.status !== 'loaded') {
return undefined;
}
return targetEntry.runtime.module as T;
};
return {
core: this.core,
oneBot: this.obContext,
actions: this.actions,
pluginName: entry.id,
pluginPath: entry.pluginPath,
dataPath,
configPath,
NapCatConfig,
adapterName: this.name,
pluginManager: this,
logger: pluginLogger,
router,
getPluginExports,
};
}
// ==================== 公共 API ====================
/**
* 获取插件目录路径
*/
public getPluginPath (): string {
return this.pluginPath;
}
/**
* 获取所有插件条目
*/
public getAllPlugins (): PluginEntry[] {
return Array.from(this.plugins.values());
}
/**
* 获取已加载的插件列表
*/
public getLoadedPlugins (): PluginEntry[] {
return Array.from(this.plugins.values()).filter(p => p.loaded);
}
/**
* 通过 ID 获取插件信息
*/
public getPluginInfo (pluginId: string): PluginEntry | undefined {
return this.plugins.get(pluginId);
}
/**
* 设置插件状态(启用/禁用)
*/
public async setPluginStatus (pluginId: string, enable: boolean): Promise<void> {
const config = this.getPluginConfig();
config[pluginId] = enable;
this.savePluginConfig(config);
const entry = this.plugins.get(pluginId);
if (entry) {
entry.enable = enable;
if (enable && !entry.loaded) {
// 启用插件
await this.loadPlugin(entry);
} else if (!enable && entry.loaded) {
// 禁用插件
await this.unloadPlugin(entry);
}
}
}
/**
* 通过 ID 加载插件
*/
public async loadPluginById (pluginId: string): Promise<boolean> {
let entry = this.plugins.get(pluginId);
if (!entry) {
// 尝试查找并扫描
const dirname = this.loader.findPluginDirById(pluginId);
if (!dirname) {
this.logger.logWarn(`[PluginManager] Plugin ${pluginId} not found in filesystem`);
return false;
}
const newEntry = this.loader.rescanPlugin(dirname);
if (!newEntry) {
return false;
}
this.plugins.set(newEntry.id, newEntry);
entry = newEntry;
}
if (!entry.enable) {
this.logger.log(`[PluginManager] Skipping loading disabled plugin: ${pluginId}`);
return false;
}
return await this.loadPlugin(entry);
}
/**
* 卸载插件(仅从内存卸载)
*/
public async unregisterPlugin (pluginId: string): Promise<void> {
const entry = this.plugins.get(pluginId);
if (entry) {
await this.unloadPlugin(entry);
}
}
/**
* 卸载并删除插件
*/
public async uninstallPlugin (pluginId: string, cleanData: boolean = false): Promise<void> {
const entry = this.plugins.get(pluginId);
if (!entry) {
throw new Error(`Plugin ${pluginId} not found`);
}
const pluginPath = entry.pluginPath;
const dataPath = path.join(this.core.context.pathWrapper.configPath, 'plugins', pluginId);
// 先卸载插件
await this.unloadPlugin(entry);
// 从注册表移除
this.plugins.delete(pluginId);
// 删除插件目录
if (fs.existsSync(pluginPath)) {
fs.rmSync(pluginPath, { recursive: true, force: true });
}
// 清理插件配置数据
if (cleanData && fs.existsSync(dataPath)) {
fs.rmSync(dataPath, { recursive: true, force: true });
}
}
/**
* 重载指定插件
*/
public async reloadPlugin (pluginId: string): Promise<boolean> {
const entry = this.plugins.get(pluginId);
if (!entry) {
this.logger.logWarn(`[PluginManager] Plugin ${pluginId} not found`);
return false;
}
try {
// 卸载插件
await this.unloadPlugin(entry);
// 重新扫描
const newEntry = this.loader.rescanPlugin(entry.fileId);
if (!newEntry) {
return false;
}
// 更新注册表
this.plugins.set(newEntry.id, newEntry);
// 重新加载
if (newEntry.enable) {
await this.loadPlugin(newEntry);
}
this.logger.log(`[PluginManager] Plugin ${pluginId} reloaded successfully`);
return true;
} catch (error) {
this.logger.logError(`[PluginManager] Error reloading plugin ${pluginId}:`, error);
return false;
}
}
/**
* 加载目录插件(用于新安装的插件)
*/
public async loadDirectoryPlugin (dirname: string): Promise<void> {
const entry = this.loader.rescanPlugin(dirname);
if (!entry) {
return;
}
// 检查是否已存在
if (this.plugins.has(entry.id)) {
this.logger.logWarn(`[PluginManager] Plugin ${entry.id} already exists`);
return;
}
this.plugins.set(entry.id, entry);
if (entry.enable && entry.runtime.status !== 'error') {
await this.loadPlugin(entry);
}
}
/**
* 获取插件数据目录路径
*/
public getPluginDataPath (pluginId: string): string {
return path.join(this.core.context.pathWrapper.configPath, 'plugins', pluginId);
}
/**
* 获取插件配置文件路径
*/
public getPluginConfigPath (pluginId: string): string {
return path.join(this.getPluginDataPath(pluginId), 'config.json');
}
/**
* 获取插件路由注册器
*/
public getPluginRouter (pluginId: string): PluginRouterRegistryImpl | undefined {
return this.pluginRouters.get(pluginId);
}
/**
* 获取所有插件路由注册器
*/
public getAllPluginRouters (): Map<string, PluginRouterRegistryImpl> {
return this.pluginRouters;
}
// ==================== 事件处理 ====================
async onEvent<T extends OB11EmitEventContent> (event: T): Promise<void> {
if (!this.isEnable) {
return;
}
try {
await Promise.allSettled(
this.getLoadedPlugins().map((entry) =>
this.callPluginEventHandler(entry, event)
)
);
} catch (error) {
this.logger.logError('[PluginManager] Error handling event:', error);
}
}
/**
* 调用插件的事件处理方法
*/
private async callPluginEventHandler (
entry: PluginEntry,
event: OB11EmitEventContent
): Promise<void> {
if (entry.runtime.status !== 'loaded' || !entry.runtime.module || !entry.runtime.context) {
return;
}
const { module, context } = entry.runtime;
try {
// 优先使用 plugin_onevent 方法
if (typeof module.plugin_onevent === 'function') {
await module.plugin_onevent(context, event);
}
// 如果是消息事件并且插件有 plugin_onmessage 方法,也调用
if (
(event as any).message_type &&
typeof module.plugin_onmessage === 'function'
) {
await module.plugin_onmessage(context, event as OB11Message);
}
} catch (error) {
this.logger.logError(`[PluginManager] Error calling plugin ${entry.id} event handler:`, error);
}
}
// ==================== 生命周期 ====================
async open (): Promise<void> {
if (this.isEnable) {
return;
}
this.logger.log('[PluginManager] Opening plugin manager...');
this.isEnable = true;
// 扫描并加载所有插件
await this.scanAndLoadPlugins();
this.logger.log(`[PluginManager] Plugin manager opened with ${this.getLoadedPlugins().length} plugins loaded`);
}
async close (): Promise<void> {
if (!this.isEnable) {
return;
}
this.logger.log('[PluginManager] Closing plugin manager...');
this.isEnable = false;
// 卸载所有已加载的插件
for (const entry of this.plugins.values()) {
if (entry.loaded) {
await this.unloadPlugin(entry);
}
}
this.logger.log('[PluginManager] Plugin manager closed');
}
async reload (): Promise<OB11NetworkReloadType> {
this.logger.log('[PluginManager] Reloading plugin manager...');
// 先关闭然后重新打开
await this.close();
await this.open();
this.logger.log('[PluginManager] Plugin manager reloaded');
return OB11NetworkReloadType.Normal;
}
}
+1 -75
View File
@@ -2,84 +2,10 @@ 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();
// 依赖排除
const external = [];
// 构建后拷贝插件
function copyToShellPlugin () {
return {
name: 'copy-to-shell',
writeBundle () {
try {
const sourceDir = resolve(__dirname, 'dist');
const targetDir = resolve(__dirname, '../napcat-shell/dist/plugins/napcat-plugin-builtin');
const packageJsonSource = resolve(__dirname, 'package.json');
const webuiSourceDir = resolve(__dirname, 'webui');
const webuiTargetDir = resolve(targetDir, 'webui');
// 确保目标目录存在
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++;
}
// 拷贝 webui 目录
if (fs.existsSync(webuiSourceDir)) {
copyDirRecursive(webuiSourceDir, webuiTargetDir);
console.log(`[copy-to-shell] Copied webui directory to ${webuiTargetDir}`);
}
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;
}
},
};
}
// 递归复制目录
function copyDirRecursive (src: string, dest: string) {
if (!fs.existsSync(dest)) {
fs.mkdirSync(dest, { recursive: true });
}
const entries = fs.readdirSync(src, { withFileTypes: true });
for (const entry of entries) {
const srcPath = resolve(src, entry.name);
const destPath = resolve(dest, entry.name);
if (entry.isDirectory()) {
copyDirRecursive(srcPath, destPath);
} else {
fs.copyFileSync(srcPath, destPath);
}
}
}
export default defineConfig({
resolve: {
@@ -102,5 +28,5 @@ export default defineConfig({
external: [...nodeModules, ...external],
},
},
plugins: [nodeResolve(), copyToShellPlugin()],
plugins: [nodeResolve()],
});
+1
View File
@@ -794,6 +794,7 @@ export class NapCatShell {
// 监听下线通知并同步到 WebUI
this.core.event.on('KickedOffLine', (tips: string) => {
WebUiDataRuntime.setQQLoginStatus(false);
WebUiDataRuntime.setQQLoginError(tips);
});
// 使用 NapCatAdapterManager 统一管理协议适配器
+1 -1
View File
@@ -54,7 +54,7 @@ const ShellBaseConfig = (source_map: boolean = false) =>
build: {
sourcemap: source_map,
target: 'esnext',
minify: false,
minify: source_map ? false : 'esbuild',
lib: {
entry: {
napcat: path.resolve(__dirname, 'napcat.ts'),
+111 -8
View File
@@ -1,17 +1,18 @@
import { RequestHandler } from 'express';
import { AuthHelper } from '@/napcat-webui-backend/src/helper/SignToken';
import { PasskeyHelper } from '@/napcat-webui-backend/src/helper/PasskeyHelper';
import { TotpHelper } from '@/napcat-webui-backend/src/helper/TotpHelper';
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';
import { WebUiConfig, getInitialWebUiToken, setInitialWebUiToken } from '@/napcat-webui-backend/index';
// 登录
// 登录 - 支持2FA验证
export const LoginHandler: RequestHandler = async (req, res) => {
// 获取WebUI配置
const WebUiConfigData = await WebUiConfig.GetWebUIConfig();
// 获取请求体中的hash
const { hash } = req.body;
// 获取请求体中的hash和totpCode
const { hash, totpCode } = req.body;
// 获取客户端IP
const clientIP = req.ip || req.socket.remoteAddress || '';
@@ -33,11 +34,31 @@ export const LoginHandler: RequestHandler = async (req, res) => {
return sendError(res, 'token is invalid');
}
// 签发凭证
const signCredential = Buffer.from(JSON.stringify(AuthHelper.signCredential(hash))).toString(
'base64'
);
// 返回成功信息
// 检查是否启用了2FA
if (WebUiConfigData.enable2FA && WebUiConfigData.totpSecret) {
// 如果没有提供验证码,返回要求验证码
if (!totpCode) {
return sendSuccess(res, {
require2FA: true,
message: 'Please enter your authenticator code',
});
}
// 验证TOTP验证码
if (!TotpHelper.verifyTotp(WebUiConfigData.totpSecret, totpCode)) {
return sendError(res, 'Invalid or expired code');
}
// 2FA验证成功,签发凭证
const signCredential = Buffer.from(JSON.stringify(AuthHelper.signCredential(hash))).toString('base64');
return sendSuccess(res, {
Credential: signCredential,
require2FA: false,
});
}
// 未启用2FA,直接签发凭证
const signCredential = Buffer.from(JSON.stringify(AuthHelper.signCredential(hash))).toString('base64');
return sendSuccess(res, {
Credential: signCredential,
});
@@ -261,3 +282,85 @@ export const VerifyPasskeyAuthenticationHandler: RequestHandler = async (req, re
return sendError(res, `Authentication verification failed: ${(error as Error).message}`);
}
};
// 获取2FA状态
export const Get2FAStatusHandler: RequestHandler = async (_req, res) => {
try {
const WebUiConfigData = await WebUiConfig.GetWebUIConfig();
return sendSuccess(res, {
enable2FA: WebUiConfigData.enable2FA || false,
hasSecret: !!WebUiConfigData.totpSecret,
});
} catch (error) {
return sendError(res, `获取2FA状态失败: ${(error as Error).message}`);
}
};
// 生成2FA密钥
export const Generate2FASecretHandler: RequestHandler = async (_req, res) => {
try {
const secret = TotpHelper.generateSecret();
const qrCodeUrl = TotpHelper.generateQrCodeUrl(secret, 'NapCat WebUI', 'NapCat');
return sendSuccess(res, {
secret,
qrCodeUrl,
});
} catch (error) {
return sendError(res, `Failed to generate 2FA secret: ${(error as Error).message}`);
}
};
// 启用2FA
export const Enable2FAHandler: RequestHandler = async (req, res) => {
try {
const { secret, totpCode } = req.body;
if (!secret || !totpCode) {
return sendError(res, 'secret and totpCode are required');
}
if (!TotpHelper.verifyTotp(secret, totpCode)) {
return sendError(res, 'Invalid code');
}
await WebUiConfig.UpdateWebUIConfig({
enable2FA: true,
totpSecret: secret,
});
return sendSuccess(res, { message: '2FA enabled' });
} catch (error) {
return sendError(res, `Failed to enable 2FA: ${(error as Error).message}`);
}
};
// 禁用2FA - 需要验证当前TOTP代码
export const Disable2FAHandler: RequestHandler = async (req, res) => {
try {
const { totpCode } = req.body;
if (!totpCode) {
return sendError(res, 'totpCode is required to disable 2FA');
}
const WebUiConfigData = await WebUiConfig.GetWebUIConfig();
if (!WebUiConfigData.totpSecret) {
return sendError(res, '2FA is not enabled');
}
// 验证当前TOTP代码
if (!TotpHelper.verifyTotp(WebUiConfigData.totpSecret, totpCode)) {
return sendError(res, 'Invalid code');
}
await WebUiConfig.UpdateWebUIConfig({
enable2FA: false,
totpSecret: '',
});
return sendSuccess(res, { message: '2FA disabled' });
} catch (error) {
return sendError(res, `Failed to disable 2FA: ${(error as Error).message}`);
}
};
@@ -0,0 +1,164 @@
import crypto from 'crypto';
/**
* TOTP (Time-based One-Time Password) Helper
* 用于生成和验证基于时间的一次性密码
*/
export class TotpHelper {
/**
* 生成随机密钥(Base32格式)
* @param length 密钥长度(字节),默认16字节
* @returns Base32编码的密钥
*/
static generateSecret(length: number = 16): string {
const buffer = crypto.randomBytes(length);
return this.toBase32(buffer);
}
/**
* 验证一次性密码
* @param secret Base32编码的密钥
* @param code 用户输入的验证码
* @param timeStep 时间步长(秒),默认30秒
* @param window 允许的时间窗口(前后各多少个时间步长),默认1
* @returns 是否验证通过
*/
static verifyTotp(
secret: string,
code: string,
timeStep: number = 30,
window: number = 1
): boolean {
const time = Math.floor(Date.now() / 1000 / timeStep);
// 检查前后 window 个时间步长
for (let i = -window; i <= window; i++) {
const candidateCode = this.generateHotp(secret, time + i);
if (candidateCode === code) {
return true;
}
}
return false;
}
/**
* 生成 HOTP (HMAC-based One-Time Password)
* @param secret Base32编码的密钥
* @param counter 计数器
* @returns 6位数字验证码
*/
private static generateHotp(secret: string, counter: number): string {
// 将 Base32 密钥转换为字节
const key = this.base32ToBytes(secret);
// 将计数器转换为 8 字节大端序
const counterBytes = Buffer.alloc(8);
let tempCounter = counter;
for (let i = 7; i >= 0; i--) {
counterBytes[i] = tempCounter & 0xff;
tempCounter = Math.floor(tempCounter / 256);
}
// 计算 HMAC-SHA1
const hmac = crypto.createHmac('sha1', key);
hmac.update(counterBytes);
const hash = hmac.digest();
// 动态截断
const hashLength = hash.length;
const lastByte = hash[hashLength - 1];
if (lastByte === undefined) {
return '000000';
}
const offset = lastByte & 0x0f;
const byte0 = hash[offset] ?? 0;
const byte1 = hash[offset + 1] ?? 0;
const byte2 = hash[offset + 2] ?? 0;
const byte3 = hash[offset + 3] ?? 0;
const binary =
((byte0 & 0x7f) << 24) |
((byte1 & 0xff) << 16) |
((byte2 & 0xff) << 8) |
(byte3 & 0xff);
// 生成 6 位数字
const otp = binary % 1000000;
return otp.toString().padStart(6, '0');
}
/**
* 生成 QR Code URL
* @param secret Base32编码的密钥
* @param account 账户名称
* @param issuer 发行方名称
* @returns otpauth:// URL
*/
static generateQrCodeUrl(
secret: string,
account: string,
issuer: string
): string {
const encodedIssuer = encodeURIComponent(issuer);
const encodedAccount = encodeURIComponent(`${issuer}:${account}`);
return `otpauth://totp/${encodedAccount}?secret=${secret}&issuer=${encodedIssuer}&algorithm=SHA1&digits=6&period=30`;
}
/**
* 将字节数组转换为 Base32 编码
* @param buffer 字节数组
* @returns Base32编码字符串
*/
private static toBase32(buffer: Buffer): string {
const base32Alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
let output = '';
for (let i = 0; i < buffer.length; i += 5) {
const b0 = buffer[i] ?? 0;
const b1 = buffer[i + 1] ?? 0;
const b2 = buffer[i + 2] ?? 0;
const b3 = buffer[i + 3] ?? 0;
const b4 = buffer[i + 4] ?? 0;
output += base32Alphabet[(b0 >> 3) & 0x1f];
output += base32Alphabet[((b0 << 2) | (b1 >> 6)) & 0x1f];
output += base32Alphabet[(b1 >> 1) & 0x1f];
output += base32Alphabet[((b1 << 4) | (b2 >> 4)) & 0x1f];
output += base32Alphabet[((b2 << 1) | (b3 >> 7)) & 0x1f];
output += base32Alphabet[(b3 >> 2) & 0x1f];
output += base32Alphabet[((b3 << 3) | (b4 >> 5)) & 0x1f];
output += base32Alphabet[b4 & 0x1f];
}
// 移除填充的等号
return output.replace(/=+$/, '');
}
/**
* 将 Base32 字符串转换为字节数组
* @param base32 Base32编码字符串
* @returns 字节数组
*/
private static base32ToBytes(base32: string): Buffer {
const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
const base32Clean = base32.toUpperCase().replace(/=+$/, '');
const bytes: number[] = [];
let buffer = 0;
let bitsLeft = 0;
for (const char of base32Clean) {
const value = alphabet.indexOf(char);
if (value === -1) continue;
buffer = (buffer << 5) | value;
bitsLeft += 5;
if (bitsLeft >= 8) {
bytes.push((buffer >> (bitsLeft - 8)) & 0xff);
bitsLeft -= 8;
}
}
return Buffer.from(bytes);
}
}
@@ -33,6 +33,10 @@ const WebUiConfigSchema = Type.Object({
ipBlacklist: Type.Array(Type.String(), { default: [] }),
// 是否启用 X-Forwarded-For 获取真实IP
enableXForwardedFor: Type.Boolean({ default: false }),
// 是否启用双因素认证(2FA)
enable2FA: Type.Boolean({ default: false }),
// TOTP 密钥
totpSecret: Type.String({ default: '' }),
});
export type WebUiConfigType = Static<typeof WebUiConfigSchema>;
@@ -9,6 +9,10 @@ import {
VerifyPasskeyRegistrationHandler,
GeneratePasskeyAuthenticationOptionsHandler,
VerifyPasskeyAuthenticationHandler,
Get2FAStatusHandler,
Generate2FASecretHandler,
Enable2FAHandler,
Disable2FAHandler,
} from '@/napcat-webui-backend/src/api/Auth';
const router: Router = Router();
@@ -28,5 +32,13 @@ router.post('/passkey/verify-registration', VerifyPasskeyRegistrationHandler);
router.post('/passkey/generate-authentication-options', GeneratePasskeyAuthenticationOptionsHandler);
// router:验证Passkey认证
router.post('/passkey/verify-authentication', VerifyPasskeyAuthenticationHandler);
// router:获取2FA状态
router.get('/2fa/status', Get2FAStatusHandler);
// router:生成2FA密钥
router.post('/2fa/generate-secret', Generate2FASecretHandler);
// router:启用2FA
router.post('/2fa/enable', Enable2FAHandler);
// router:禁用2FA
router.post('/2fa/disable', Disable2FAHandler);
export { router as AuthRouter };
@@ -17,13 +17,43 @@ export default class WebUIManager {
return data.data;
}
public static async loginWithToken (token: string) {
public static async loginWithToken (token: string, totpCode?: string) {
const sha256 = CryptoJS.SHA256(token + '.napcat').toString();
const { data } = await serverRequest.post<ServerResponse<AuthResponse>>(
'/auth/login',
{ hash: sha256 }
{ hash: sha256, totpCode }
);
return data.data.Credential;
return data.data;
}
public static async get2FAStatus () {
const { data } = await serverRequest.get<ServerResponse<{ enable2FA: boolean; hasSecret: boolean; }>>(
'/auth/2fa/status'
);
return data.data;
}
public static async generate2FASecret () {
const { data } = await serverRequest.post<ServerResponse<{ secret: string; qrCodeUrl: string; }>>(
'/auth/2fa/generate-secret'
);
return data.data;
}
public static async enable2FA (secret: string, totpCode: string) {
const { data } = await serverRequest.post<ServerResponse<{ message: string; }>>(
'/auth/2fa/enable',
{ secret, totpCode }
);
return data.data;
}
public static async disable2FA (totpCode: string) {
const { data } = await serverRequest.post<ServerResponse<{ message: string; }>>(
'/auth/2fa/disable',
{ totpCode }
);
return data.data;
}
public static async changePassword (oldToken: string, newToken: string) {
@@ -6,7 +6,8 @@ import { useNavigate, useSearchParams } from 'react-router-dom';
import key from '@/const/key';
import ChangePasswordCard from './change_password';
//把修改密码移动到WebUI栏目中
//import ChangePasswordCard from './change_password';
import LoginConfigCard from './login';
import OneBotConfigCard from './onebot';
import ServerConfigCard from './server';
@@ -101,11 +102,16 @@ export default function ConfigPage () {
<LoginConfigCard />
</ConfigPageItem>
</Tab>
//把修改密码移动到WebUI栏目中
{
/*
<Tab title='修改密码' key='token'>
<ConfigPageItem size='sm'>
<ChangePasswordCard />
</ConfigPageItem>
</Tab>
*/
}
<Tab title='主题配置' key='theme'>
<ConfigPageItem size='lg'>
@@ -1,8 +1,12 @@
import { Button } from '@heroui/button';
import { Input } from '@heroui/input';
import { useLocalStorage } from '@uidotdev/usehooks';
import { useEffect, useState } from 'react';
import { Controller, useForm } from 'react-hook-form';
import toast from 'react-hot-toast';
import { useNavigate } from 'react-router-dom';
import { IoQrCode } from 'react-icons/io5';
import { QRCodeSVG } from 'qrcode.react';
import key from '@/const/key';
@@ -50,6 +54,118 @@ const WebUIConfigCard = () => {
const [registrationOptions, setRegistrationOptions] = useState<any>(null);
const [isLoadingOptions, setIsLoadingOptions] = useState(false);
// 2FA 相关状态
const [twoFAStatus, setTwoFAStatus] = useState<{ enable2FA: boolean; hasSecret: boolean }>({ enable2FA: false, hasSecret: false });
const [twoFASecret, setTwoFASecret] = useState<string>('');
const [twoFAQrCodeUrl, setTwoFAQrCodeUrl] = useState<string>('');
const [twoFATotpCode, setTwoFATotpCode] = useState<string>('');
const [disableTotpCode, setDisableTotpCode] = useState<string>('');
const [isGeneratingSecret, setIsGeneratingSecret] = useState(false);
const [isEnabling2FA, setIsEnabling2FA] = useState(false);
const [isDisabling2FA, setIsDisabling2FA] = useState(false);
const loadTwoFAStatus = async () => {
try {
const status = await WebUIManager.get2FAStatus();
setTwoFAStatus(status);
} catch (error) {
console.error('获取2FA状态失败:', error);
}
};
const generateTwoFASecret = async () => {
setIsGeneratingSecret(true);
try {
const data = await WebUIManager.generate2FASecret();
setTwoFASecret(data.secret);
setTwoFAQrCodeUrl(data.qrCodeUrl);
toast.success('密钥已生成,请使用Authenticator应用扫码');
} catch (error) {
toast.error(`生成密钥失败: ${(error as Error).message}`);
} finally {
setIsGeneratingSecret(false);
}
};
const enableTwoFA = async () => {
if (!twoFASecret || !twoFATotpCode) {
toast.error('请先生成密钥并输入验证码');
return;
}
if (twoFATotpCode.length !== 6) {
toast.error('验证码必须是6位数字');
return;
}
setIsEnabling2FA(true);
try {
await WebUIManager.enable2FA(twoFASecret, twoFATotpCode);
await loadTwoFAStatus();
setTwoFASecret('');
setTwoFAQrCodeUrl('');
setTwoFATotpCode('');
toast.success('双因素认证已启用');
} catch (error) {
toast.error(`启用失败: ${(error as Error).message}`);
} finally {
setIsEnabling2FA(false);
}
};
const disableTwoFA = async () => {
if (!disableTotpCode || disableTotpCode.length !== 6) {
toast.error('请输入6位验证码');
return;
}
setIsDisabling2FA(true);
try {
await WebUIManager.disable2FA(disableTotpCode);
await loadTwoFAStatus();
setDisableTotpCode('');
toast.success('双因素认证已禁用');
} catch (error) {
toast.error(`禁用失败: ${(error as Error).message}`);
} finally {
setIsDisabling2FA(false);
}
};
useEffect(() => {
loadTwoFAStatus();
}, []);
// 修改密码独立表单
const navigate = useNavigate();
const [, setToken] = useLocalStorage(key.token, '');
const {
control: pwdControl,
handleSubmit: handlePwdSubmit,
formState: { isSubmitting: isPwdSubmitting, errors: pwdErrors },
watch,
} = useForm<{
oldToken: string;
newToken: string;
}>({
defaultValues: {
oldToken: '',
newToken: '',
},
});
const oldTokenValue = watch('oldToken');
// 修复类型错误:显式包装为无参函数,满足 onPress 的类型要求
const onPasswordSubmit = handlePwdSubmit(async (data) => {
try {
await WebUIManager.changePassword(data.oldToken, data.newToken);
toast.success('修改成功');
setToken('');
localStorage.removeItem(key.token);
navigate('/web_login');
} catch (error) {
const msg = (error as Error).message;
toast.error(`修改失败: ${msg}`);
}
});
// 预先获取注册选项(可以在任何时候调用)
const preloadRegistrationOptions = async () => {
setIsLoadingOptions(true);
@@ -90,6 +206,86 @@ const WebUIConfigCard = () => {
return (
<>
<title>WebUI配置 - NapCat WebUI</title>
{/* 修改密码区块 - 移到顶部 */}
<div className='flex flex-col gap-4'>
<div className='flex-shrink-0 w-full font-bold text-default-600 dark:text-default-400 px-1'>修改密码</div>
<Controller
control={pwdControl}
name='oldToken'
rules={{
required: '旧密码不能为空',
validate: (value) => {
if (!value || value.trim().length === 0) {
return '旧密码不能为空';
}
return true;
},
}}
render={({ field }) => (
<Input
{...field}
label='旧密码'
placeholder='请输入旧密码'
type='password'
isRequired
isInvalid={!!pwdErrors.oldToken}
errorMessage={pwdErrors.oldToken?.message}
/>
)}
/>
<Controller
control={pwdControl}
name='newToken'
rules={{
required: '新密码不能为空',
minLength: {
value: 6,
message: '新密码至少需要6个字符',
},
validate: (value) => {
if (!value || value.trim().length === 0) {
return '新密码不能为空';
}
if (value.trim().length !== value.length) {
return '新密码不能包含前后空格';
}
if (value === oldTokenValue) {
return '新密码不能与旧密码相同';
}
if (!/[a-zA-Z]/.test(value)) {
return '新密码必须包含字母';
}
if (!/[0-9]/.test(value)) {
return '新密码必须包含数字';
}
return true;
},
}}
render={({ field }) => (
<Input
{...field}
label='新密码'
placeholder='至少6位,包含字母和数字'
type='password'
isRequired
isInvalid={!!pwdErrors.newToken}
errorMessage={pwdErrors.newToken?.message}
/>
)}
/>
{/* 自定义确认按钮,无取消按钮;onPress 调用 onPasswordSubmit(已通过 handlePwdSubmit 包装,类型兼容) */}
<div className='flex justify-end'>
<Button
color='primary'
onPress={() => { onPasswordSubmit(); }}
isLoading={isPwdSubmitting}
>
确认修改密码
</Button>
</div>
</div>
<div className='flex flex-col gap-2'>
<div className='flex-shrink-0 w-full font-bold text-default-600 dark:text-default-400 px-1'>背景图</div>
<Controller
@@ -251,6 +447,111 @@ const WebUIConfigCard = () => {
</>
)}
</div>
{/* 双因素认证 (2FA) */}
<div className='flex flex-col gap-2'>
<div className='flex-shrink-0 w-full font-bold text-default-600 dark:text-default-400 px-1 flex items-center gap-2'>
<span>双因素认证 (2FA)</span>
<span className={`text-sm px-2 py-0.5 rounded-full ${twoFAStatus.enable2FA ? 'bg-green-100 text-green-700' : 'bg-default-200 text-default-600'}`}>
{twoFAStatus.enable2FA ? '已启用' : '已禁用'}
</span>
</div>
{twoFAStatus.enable2FA ? (
<div className='bg-green-50 border border-green-200 rounded-lg p-4'>
<div className='text-sm text-green-700 mb-3'>✅ 双因素认证已启用</div>
<div className='mb-3'>
<div className='text-sm text-default-600 mb-2'>输入验证码以禁用</div>
<input
type='text'
inputMode='numeric'
pattern='[0-9]*'
maxLength={6}
value={disableTotpCode}
onChange={(e) => setDisableTotpCode(e.target.value.replace(/\D/g, ''))}
placeholder='000000'
className='w-32 px-3 py-2 border border-default-300 rounded-lg text-center text-lg tracking-widest'
/>
</div>
<Button
color='danger'
variant='flat'
onPress={disableTwoFA}
isLoading={isDisabling2FA}
disabled={!disableTotpCode || disableTotpCode.length !== 6}
className='w-fit'
>
禁用双因素认证
</Button>
</div>
) : (
<>
<div className='text-sm text-default-400 mb-2'>
启用双因素认证后,登录时需要额外输入Authenticator应用生成的验证码
</div>
<div className='bg-default-50 border border-default-200 rounded-lg p-4'>
<Button
color='secondary'
variant='flat'
onPress={generateTwoFASecret}
isLoading={isGeneratingSecret}
className='w-fit mb-4'
>
<IoQrCode className='mr-2' />
生成密钥
</Button>
{twoFASecret && (
<>
<div className='mb-4'>
<div className='text-sm text-default-600 mb-2'>请使用 Authenticator 应用扫描下方二维码</div>
<div className='flex items-center gap-4'>
<div className='bg-white border border-default-300 rounded-lg p-3'>
<QRCodeSVG
value={twoFAQrCodeUrl}
size={128}
level='M'
includeMargin={false}
/>
</div>
<div>
<div className='text-xs text-default-500 mb-1'>密钥(手动输入用)</div>
<div className='font-mono text-sm bg-default-100 px-3 py-2 rounded break-all max-w-[200px]'>
{twoFASecret}
</div>
</div>
</div>
</div>
<div className='mb-4'>
<div className='text-sm text-default-600 mb-2'>输入Authenticator验证码</div>
<input
type='text'
inputMode='numeric'
pattern='[0-9]*'
maxLength={6}
value={twoFATotpCode}
onChange={(e) => setTwoFATotpCode(e.target.value.replace(/\D/g, ''))}
placeholder='000000'
className='w-32 px-3 py-2 border border-default-300 rounded-lg text-center text-lg tracking-widest'
/>
</div>
<Button
color='primary'
variant='flat'
onPress={enableTwoFA}
isLoading={isEnabling2FA}
disabled={!twoFATotpCode || twoFATotpCode.length !== 6}
className='w-fit'
>
启用双因素认证
</Button>
</>
)}
</div>
</>
)}
</div>
<SaveButtons
onSubmit={onSubmit}
reset={reset}
@@ -260,4 +561,4 @@ const WebUIConfigCard = () => {
);
};
export default WebUIConfigCard;
export default WebUIConfigCard;
@@ -5,7 +5,7 @@ import { Input } from '@heroui/input';
import { useLocalStorage } from '@uidotdev/usehooks';
import { useEffect, useState } from 'react';
import { toast } from 'react-hot-toast';
import { IoKeyOutline } from 'react-icons/io5';
import { IoKeyOutline, IoArrowBack } from 'react-icons/io5';
import { useNavigate } from 'react-router-dom';
import logo from '@/assets/images/logo.png';
@@ -29,6 +29,11 @@ export default function WebLoginPage () {
const [isPasskeyLoading, setIsPasskeyLoading] = useState<boolean>(true); // 初始为true,表示正在检查passkey
const [, setLocalToken] = useLocalStorage<string>(key.token, '');
// 2FA相关状态
const [require2FA, setRequire2FA] = useState<boolean>(false);
const [totpCode, setTotpCode] = useState<string>('');
const [pendingToken, setPendingToken] = useState<string>('');
// Helper function to decode base64url
function base64UrlToUint8Array (base64Url: string): Uint8Array {
const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
@@ -102,10 +107,10 @@ export default function WebLoginPage () {
return false; // 登录失败
};
const onSubmit = async () => {
// 第一次登录(输入token)
const onSubmitToken = async () => {
if (!tokenValue) {
toast.error('请输入token');
return;
}
setIsLoading(true);
@@ -113,7 +118,18 @@ export default function WebLoginPage () {
const data = await WebUIManager.loginWithToken(tokenValue);
if (data) {
setLocalToken(data);
if (data.require2FA) {
// 需要2FA验证
setRequire2FA(true);
setPendingToken(tokenValue);
setIsLoading(false);
return;
}
// 不需要2FA,直接登录
if (data.Credential) {
setLocalToken(data.Credential);
}
navigate('/qq_login', { replace: true });
}
} catch (error) {
@@ -123,10 +139,42 @@ export default function WebLoginPage () {
}
};
// 2FA验证提交
const onSubmit2FA = async () => {
if (!totpCode || totpCode.length !== 6) {
toast.error('Please enter 6-digit code');
return;
}
setIsLoading(true);
try {
const data = await WebUIManager.loginWithToken(pendingToken, totpCode);
if (data && data.Credential) {
setLocalToken(data.Credential);
navigate('/qq_login', { replace: true });
}
} catch (error) {
toast.error((error as Error).message);
} finally {
setIsLoading(false);
}
};
// 返回token输入步骤
const goBackToToken = () => {
setRequire2FA(false);
setTotpCode('');
setPendingToken('');
};
// 处理全局键盘事件
const handleKeyDown = (e: KeyboardEvent) => {
if (e.key === 'Enter' && !isLoading && !isPasskeyLoading) {
onSubmit();
if (require2FA) {
onSubmit2FA();
} else {
onSubmitToken();
}
}
};
@@ -137,14 +185,14 @@ export default function WebLoginPage () {
return () => {
document.removeEventListener('keydown', handleKeyDown);
};
}, [tokenValue, isLoading, isPasskeyLoading]); // 依赖项包含用于登录的状态
}, [tokenValue, totpCode, isLoading, isPasskeyLoading, require2FA]); // 依赖项包含用于登录的状态
useEffect(() => {
// 如果URL中有token,直接登录
if (token) {
// 不需要检查passkey,立即清除loading状态,避免登录失败后输入框被永久禁用
setIsPasskeyLoading(false);
onSubmit();
onSubmitToken();
return;
}
@@ -188,86 +236,161 @@ export default function WebLoginPage () {
🔐 正在检查Passkey...
</div>
)}
<form
onSubmit={(e) => {
e.preventDefault();
onSubmit();
}}
>
{/* 隐藏的用户名字段,帮助浏览器识别登录表单 */}
<input
type='text'
name='username'
value='napcat-webui'
autoComplete='username'
className='absolute -left-[9999px] opacity-0 pointer-events-none'
readOnly
tabIndex={-1}
aria-label='Username'
/>
<Input
isClearable
type='password'
name='password'
autoComplete='current-password'
classNames={{
label: 'text-black/50 dark:text-white/90',
input: [
'bg-transparent',
'text-black/90 dark:text-white/90',
'placeholder:text-default-700/50 dark:placeholder:text-white/60',
],
innerWrapper: 'bg-transparent',
inputWrapper: [
'shadow-xl',
'bg-default-100/70',
'dark:bg-default/60',
'backdrop-blur-xl',
'backdrop-saturate-200',
'hover:bg-default-0/70',
'dark:hover:bg-default/70',
'group-data-[focus=true]:bg-default-100/50',
'dark:group-data-[focus=true]:bg-default/60',
'!cursor-text',
],
}}
isDisabled={isLoading || isPasskeyLoading}
label='Token'
placeholder='请输入token'
radius='lg'
size='lg'
startContent={
<IoKeyOutline className='text-black/50 mb-0.5 dark:text-white/90 text-slate-400 pointer-events-none flex-shrink-0' />
}
value={tokenValue}
onChange={(e) => setTokenValue(e.target.value)}
onClear={() => setTokenValue('')}
/>
</form>
<div className='text-center text-small text-default-600 dark:text-default-400 px-2'>
💡 提示:请从 NapCat 启动日志中查看登录密钥
</div>
<Button
className='mx-10 mt-10 text-lg py-7'
color='primary'
isLoading={isLoading}
radius='full'
size='lg'
variant='shadow'
onPress={onSubmit}
>
{!isLoading && (
<Image
alt='logo'
classNames={{
wrapper: '-ml-8',
{/* 2FA验证步骤 */}
{require2FA ? (
<>
<Button
isIconOnly
variant='light'
className='self-start -ml-2'
onPress={goBackToToken}
>
<IoArrowBack size={20} />
</Button>
<div className='text-center text-default-600 dark:text-default-400'>
请输入Authenticator中的验证码
</div>
<form
onSubmit={(e) => {
e.preventDefault();
onSubmit2FA();
}}
height='2em'
src={logo}
/>
)}
登录
</Button>
>
<Input
type='text'
inputMode='numeric'
pattern='[0-9]*'
maxLength={6}
classNames={{
label: 'text-black/50 dark:text-white/90',
input: [
'bg-transparent',
'text-black/90 dark:text-white/90',
'placeholder:text-default-700/50 dark:placeholder:text-white/60',
],
innerWrapper: 'bg-transparent',
inputWrapper: [
'shadow-xl',
'bg-default-100/70',
'dark:bg-default/60',
'backdrop-blur-xl',
'backdrop-saturate-200',
'hover:bg-default-0/70',
'dark:hover:bg-default/70',
'group-data-[focus=true]:bg-default-100/50',
'dark:group-data-[focus=true]:bg-default/60',
'!cursor-text',
],
}}
isDisabled={isLoading}
label='验证码'
placeholder='请输入6位验证码'
radius='lg'
size='lg'
startContent={
<IoKeyOutline className='text-black/50 mb-0.5 dark:text-white/90 text-slate-400 pointer-events-none flex-shrink-0' />
}
value={totpCode}
onChange={(e) => setTotpCode(e.target.value.replace(/\D/g, ''))}
/>
</form>
<Button
className='mx-10 mt-10 text-lg py-7'
color='primary'
isLoading={isLoading}
radius='full'
size='lg'
variant='shadow'
onPress={onSubmit2FA}
>
验证
</Button>
</>
) : (
<>
<form
onSubmit={(e) => {
e.preventDefault();
onSubmitToken();
}}
>
{/* 隐藏的用户名字段,帮助浏览器识别登录表单 */}
<input
type='text'
name='username'
value='napcat-webui'
autoComplete='username'
className='absolute -left-[9999px] opacity-0 pointer-events-none'
readOnly
tabIndex={-1}
aria-label='Username'
/>
<Input
isClearable
type='password'
name='password'
autoComplete='current-password'
classNames={{
label: 'text-black/50 dark:text-white/90',
input: [
'bg-transparent',
'text-black/90 dark:text-white/90',
'placeholder:text-default-700/50 dark:placeholder:text-white/60',
],
innerWrapper: 'bg-transparent',
inputWrapper: [
'shadow-xl',
'bg-default-100/70',
'dark:bg-default/60',
'backdrop-blur-xl',
'backdrop-saturate-200',
'hover:bg-default-0/70',
'dark:hover:bg-default/70',
'group-data-[focus=true]:bg-default-100/50',
'dark:group-data-[focus=true]:bg-default/60',
'!cursor-text',
],
}}
isDisabled={isLoading || isPasskeyLoading}
label='Token'
placeholder='请输入token'
radius='lg'
size='lg'
startContent={
<IoKeyOutline className='text-black/50 mb-0.5 dark:text-white/90 text-slate-400 pointer-events-none flex-shrink-0' />
}
value={tokenValue}
onChange={(e) => setTokenValue(e.target.value)}
onClear={() => setTokenValue('')}
/>
</form>
<div className='text-center text-small text-default-600 dark:text-default-400 px-2'>
💡 提示:请从 NapCat 启动日志中查看登录密钥
</div>
<Button
className='mx-10 mt-10 text-lg py-7'
color='primary'
isLoading={isLoading}
radius='full'
size='lg'
variant='shadow'
onPress={onSubmitToken}
>
{!isLoading && (
<Image
alt='logo'
classNames={{
wrapper: '-ml-8',
}}
height='2em'
src={logo}
/>
)}
登录
</Button>
</>
)}
</CardBody>
</HoverEffectCard>
</motion.div>
+3 -1
View File
@@ -5,7 +5,9 @@ interface ServerResponse<T> {
}
interface AuthResponse {
Credential: string;
Credential?: string;
require2FA?: boolean;
message?: string;
}
interface LoginListItem {