befly 3.4.11 → 3.4.13

package/bin/index.ts

@@ -2,25 +2,16 @@
 /**
  * Befly CLI - 命令行工具入口
  * 为 Befly 框架提供项目管理和脚本执行功能
+ *
+ * 环境变量加载：
+ * 1. Bun 自动加载：根据 NODE_ENV 自动加载 .env.{NODE_ENV} 文件
+ * 2. 手动指定：bun --env-file=.env.xxx befly <command>
+ * 3. 默认环境：如未设置 NODE_ENV，Bun 加载 .env.development
  */
 
-/**
- * 环境启动器
- * 必须在任何模块导入前执行
- * 父进程会在这里启动子进程并退出
- * 只有子进程会继续执行后面的代码
- */
-import { launch } from './launcher.js';
-await launch(import.meta.path);
-
-/**
- * 以下代码只在子进程中执行
- * 此时环境变量已正确加载
- */
 import { Command } from 'commander';
-import { devCommand } from '../commands/dev.js';
 import { buildCommand } from '../commands/build.js';
-import { startCommand } from '../commands/start.js';
+import { syncCommand } from '../commands/sync.js';
 import { syncDbCommand } from '../commands/syncDb.js';
 import { syncApiCommand } from '../commands/syncApi.js';
 import { syncMenuCommand } from '../commands/syncMenu.js';
@@ -130,14 +121,11 @@ function wrapCommand<T extends (...args: any[]) => any>(fn: T): T {
     }) as T;
 }
 
-// dev 命令 - 开发服务器
-program.command('dev').description('启动开发服务器').option('-p, --port <number>', '端口号', '3000').option('-h, --host <string>', '主机地址', '0.0.0.0').option('--no-sync', '跳过表同步', false).option('-v, --verbose', '详细日志', false).action(wrapCommand(devCommand));
-
 // build 命令 - 构建项目
 program.command('build').description('构建项目').option('-o, --outdir <path>', '输出目录', 'dist').option('--minify', '压缩代码', false).option('--sourcemap', '生成 sourcemap', false).action(wrapCommand(buildCommand));
 
-// start 命令 - 启动生产服务器
-program.command('start').description('启动生产服务器').option('-p, --port <number>', '端口号', '3000').option('-h, --host <string>', '主机地址', '0.0.0.0').option('-c, --cluster <instances>', '集群模式（数字或 max）').action(wrapCommand(startCommand));
+// sync 命令 - 一次性执行所有同步
+program.command('sync').description('一次性执行所有同步操作（syncApi + syncMenu + syncDev）').option('--plan', '计划模式，只显示不执行', false).option('-e, --env <environment>', '指定环境 (development, production, test)').action(wrapCommand(syncCommand));
 
 // syncDb 命令 - 同步数据库
 program.command('syncDb').description('同步数据库表结构').option('-t, --table <name>', '指定表名').option('--dry-run', '预览模式，只显示不执行', false).option('-e, --env <environment>', '指定环境 (development, production, test)').action(wrapCommand(syncDbCommand));

package/commands/sync.ts

@@ -0,0 +1,56 @@
+/**
+ * Sync 命令 - 一次性执行所有同步操作
+ * 按顺序执行：syncApi → syncMenu → syncDev
+ */
+
+import { Logger } from '../lib/logger.js';
+import { syncApiCommand } from './syncApi.js';
+import { syncMenuCommand } from './syncMenu.js';
+import { syncDevCommand } from './syncDev.js';
+import { existsSync, mkdirSync } from 'node:fs';
+
+interface SyncOptions {
+    env?: string;
+    plan?: boolean;
+}
+
+export async function syncCommand(options: SyncOptions = {}) {
+    try {
+        Logger.info('========================================');
+        Logger.info('开始执行完整同步流程');
+        Logger.info('========================================\n');
+
+        const startTime = Date.now();
+
+        // 确保 logs 目录存在
+        if (!existsSync('./logs')) {
+            mkdirSync('./logs', { recursive: true });
+            Logger.info('✅ 已创建 logs 目录\n');
+        }
+
+        // 1. 同步接口（并缓存）
+        Logger.info('【步骤 1/3】同步接口数据\n');
+        await syncApiCommand(options);
+        Logger.info('\n✅ 接口同步完成\n');
+
+        // 2. 同步菜单（并缓存）
+        Logger.info('【步骤 2/3】同步菜单数据\n');
+        await syncMenuCommand(options);
+        Logger.info('\n✅ 菜单同步完成\n');
+
+        // 3. 同步开发管理员（并缓存角色权限）
+        Logger.info('【步骤 3/3】同步开发管理员\n');
+        await syncDevCommand(options);
+        Logger.info('\n✅ 开发管理员同步完成\n');
+
+        // 输出总结
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        Logger.info('========================================');
+        Logger.info('🎉 所有同步操作已完成！');
+        Logger.info(`总耗时: ${totalTime} 秒`);
+        Logger.info('========================================');
+    } catch (error: any) {
+        Logger.error('同步过程中发生错误:', error);
+        process.exit(1);
+    }
+}

package/commands/syncApi.ts

@@ -14,6 +14,7 @@
 
 import { Logger } from '../lib/logger.js';
 import { Database } from '../lib/database.js';
+import { RedisHelper } from '../lib/redisHelper.js';
 import { scanAddons, getAddonDir, addonDirExists } from '../util.js';
 import { readdirSync, statSync } from 'node:fs';
 import { join, dirname, relative, basename } from 'pathe';
@@ -317,7 +318,26 @@ export async function syncApiCommand(options: SyncApiOptions = {}) {
         Logger.info(`更新接口: ${stats.updated} 个`);
         Logger.info(`删除接口: ${deletedCount} 个`);
         Logger.info(`当前总接口数: ${apis.length} 个`);
-        Logger.info('提示: 接口缓存将在服务器启动时自动完成');
+
+        // 6. 缓存接口数据到 Redis
+        Logger.info('\n=== 步骤 4: 缓存接口数据到 Redis ===');
+        try {
+            const apiList = await helper.getAll({
+                table: 'core_api',
+                fields: ['id', 'name', 'path', 'method', 'description', 'addonName', 'addonTitle'],
+                orderBy: ['addonName#ASC', 'path#ASC']
+            });
+
+            const result = await RedisHelper.setObject('apis:all', apiList);
+
+            if (result === null) {
+                Logger.warn('⚠️ 接口缓存失败');
+            } else {
+                Logger.info(`✅ 已缓存 ${apiList.length} 个接口到 Redis (Key: apis:all)`);
+            }
+        } catch (error: any) {
+            Logger.error('⚠️ 接口缓存异常:', error);
+        }
     } catch (error: any) {
         Logger.error('API 同步失败:', error);
         process.exit(1);

package/commands/syncDev.ts

@@ -165,6 +165,67 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
             });
             Logger.info(`✅ 开发管理员已初始化：email=${Env.DEV_EMAIL}, username=dev, roleCode=dev, roleType=admin`);
         }
+
+        // 缓存角色权限数据到 Redis
+        Logger.info('\n=== 缓存角色权限到 Redis ===');
+        try {
+            // 检查必要的表是否存在
+            const apiTableExists = await helper.tableExists('core_api');
+            const roleTableExists = await helper.tableExists('core_role');
+
+            if (!apiTableExists || !roleTableExists) {
+                Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
+            } else {
+                // 查询所有角色
+                const roles = await helper.getAll({
+                    table: 'core_role',
+                    fields: ['id', 'code', 'apis']
+                });
+
+                // 查询所有接口
+                const allApis = await helper.getAll({
+                    table: 'core_api',
+                    fields: ['id', 'name', 'path', 'method', 'description', 'addonName']
+                });
+
+                const redis = Database.getRedis();
+                let cachedRoles = 0;
+
+                // 为每个角色缓存接口权限
+                for (const role of roles) {
+                    if (!role.apis) continue;
+
+                    // 解析角色的接口 ID 列表
+                    const apiIds = role.apis
+                        .split(',')
+                        .map((id: string) => parseInt(id.trim()))
+                        .filter((id: number) => !isNaN(id));
+
+                    // 根据 ID 过滤出接口路径
+                    const roleApiPaths = allApis.filter((api: any) => apiIds.includes(api.id)).map((api: any) => `${api.method}${api.path}`);
+
+                    if (roleApiPaths.length === 0) continue;
+
+                    // 使用 Redis Set 缓存角色权限
+                    const redisKey = `role:apis:${role.code}`;
+
+                    // 先删除旧数据
+                    await redis.del(redisKey);
+
+                    // 批量添加到 Set
+                    const result = await redis.sadd(redisKey, roleApiPaths);
+
+                    if (result > 0) {
+                        cachedRoles++;
+                        Logger.debug(`   └ 角色 ${role.code}: ${result} 个接口`);
+                    }
+                }
+
+                Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限`);
+            }
+        } catch (error: any) {
+            Logger.error('⚠️ 角色权限缓存异常:', error);
+        }
     } catch (error: any) {
         Logger.error('开发管理员同步失败:', error);
         process.exit(1);

package/commands/syncMenu.ts

@@ -16,6 +16,7 @@
 
 import { Logger } from '../lib/logger.js';
 import { Database } from '../lib/database.js';
+import { RedisHelper } from '../lib/redisHelper.js';
 import { join } from 'pathe';
 import { existsSync } from 'node:fs';
 import { coreDir, projectDir } from '../paths.js';
@@ -370,7 +371,26 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
         Logger.info(`删除菜单: ${deletedCount} 个`);
         Logger.info(`当前父级菜单: ${allMenus.filter((m: any) => m.pid === 0).length} 个`);
         Logger.info(`当前子级菜单: ${allMenus.filter((m: any) => m.pid !== 0).length} 个`);
-        Logger.info('提示: 菜单缓存将在服务器启动时自动完成');
+
+        // 9. 缓存菜单数据到 Redis
+        Logger.info('\n=== 步骤 8: 缓存菜单数据到 Redis ===');
+        try {
+            const menus = await helper.getAll({
+                table: 'core_menu',
+                fields: ['id', 'pid', 'name', 'path', 'icon', 'type', 'sort'],
+                orderBy: ['sort#ASC', 'id#ASC']
+            });
+
+            const result = await RedisHelper.setObject('menus:all', menus);
+
+            if (result === null) {
+                Logger.warn('⚠️ 菜单缓存失败');
+            } else {
+                Logger.info(`✅ 已缓存 ${menus.length} 个菜单到 Redis (Key: menus:all)`);
+            }
+        } catch (error: any) {
+            Logger.error('⚠️ 菜单缓存异常:', error);
+        }
     } catch (error: any) {
         Logger.error('菜单同步失败:', error);
         process.exit(1);

package/lib/database.ts

@@ -92,6 +92,7 @@ export class Database {
             this.sqlClient = sql;
             return sql;
         } catch (error: any) {
+            Logger.debug('数据库连接字符串:', finalUrl);
             Logger.error('数据库连接测试失败', error);
 
             try {

package/lifecycle/lifecycle.ts

@@ -50,14 +50,7 @@ export class Lifecycle {
         // 3. 加载所有 API（addon + app）
         await this.loadAllApis();
 
-        // 4. 缓存数据到 Redis（接口、菜单、角色权限）
-        if (appContext.cache && appContext.redis) {
-            await appContext.cache.cacheAll();
-        } else {
-            Logger.warn('⚠️ Redis 或 Cache 插件未启用，跳过数据缓存');
-        }
-
-        // 5. 启动 HTTP 服务器
+        // 4. 启动 HTTP 服务器
         const totalStartupTime = calcPerfTime(serverStartTime);
         Logger.info(`服务器启动准备完成，总耗时: ${totalStartupTime}`);
 

package/main.ts

@@ -29,11 +29,37 @@ export class Befly {
     }
 
     /**
-     * 启动服务器
+     * 启动服务器并注册优雅关闭处理
      * @param callback - 启动完成后的回调函数
      */
     async listen(callback?: (server: Server) => void): Promise<Server> {
-        return await this.lifecycle.start(this.appContext, callback);
+        const server = await this.lifecycle.start(this.appContext, callback);
+
+        // 注册优雅关闭信号处理器
+        const gracefulShutdown = async (signal: string) => {
+            Logger.info(`\n收到 ${signal} 信号，开始优雅关闭...`);
+
+            // 1. 停止接收新请求
+            server.stop(true);
+            Logger.info('✅ HTTP 服务器已停止');
+
+            // 2. 关闭数据库连接
+            try {
+                const { Database } = await import('./lib/database.js');
+                await Database.disconnect();
+                Logger.info('✅ 数据库连接已关闭');
+            } catch (error: any) {
+                Logger.warn('⚠️ 关闭数据库连接时出错:', error.message);
+            }
+
+            Logger.info('✅ 服务器已优雅关闭');
+            process.exit(0);
+        };
+
+        process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+        process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+
+        return server;
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.4.11",
+    "version": "3.4.13",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -81,5 +81,5 @@
         "ora": "^9.0.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "d7a5eef1df6a0b46ce3202839d4deb91ac3276f9"
+    "gitHead": "f37b14e9acad47245d399709829013fda8a0c44e"
 }

package/bin/launcher.ts

@@ -1,116 +0,0 @@
-/**
- * Befly CLI 环境启动器
- * 负责检测环境参数并在正确的环境中启动子进程
- *
- * 工作原理：
- * 1. 父进程：检测 --env 参数 → 启动子进程 → 退出
- * 2. 子进程：跳过启动逻辑 → 继续执行 CLI 命令
- */
-
-import { readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * 解析环境名称
- * 支持前缀匹配（至少3个字符）
- *
- * @param input 用户输入的环境名称
- * @returns 完整的环境名称
- */
-function resolveEnvName(input: string): string {
-    // 如果输入少于3个字符，直接返回（不做匹配）
-    if (input.length < 3) {
-        return input;
-    }
-
-    // 获取项目根目录的所有 .env.* 文件
-    const rootDir = process.cwd();
-    let envFiles: string[] = [];
-
-    try {
-        const files = readdirSync(rootDir);
-        envFiles = files.filter((file) => file.startsWith('.env.') && file !== '.env.example').map((file) => file.replace('.env.', ''));
-    } catch (error) {
-        // 读取失败时直接返回原始输入
-        return input;
-    }
-
-    // 精确匹配
-    if (envFiles.includes(input)) {
-        return input;
-    }
-
-    // 前缀匹配
-    const matches = envFiles.filter((env) => env.startsWith(input.toLowerCase()));
-
-    if (matches.length === 1) {
-        return matches[0];
-    }
-
-    if (matches.length > 1) {
-        console.error(`❌ 环境名称 "${input}" 匹配到多个环境: ${matches.join(', ')}`);
-        console.error('请使用更具体的名称');
-        process.exit(1);
-    }
-
-    // 未匹配到，返回原始输入（让 Bun 处理文件不存在的情况）
-    return input;
-}
-
-/**
- * 启动环境检测和子进程
- * 如果在父进程中，会启动子进程并退出（不返回）
- * 如果在子进程中，直接返回（继续执行）
- *
- * @param entryFile CLI 入口文件的绝对路径（通常是 bin/index.ts）
- */
-export async function launch(entryFile: string): Promise<void> {
-    // 如果已经在子进程中，直接返回
-    if (process.env.BEFLY_SUBPROCESS) {
-        return;
-    }
-
-    // 确定环境名称
-    const longEnvIndex = process.argv.indexOf('--env');
-    const shortEnvIndex = process.argv.indexOf('-e');
-    let envInput = 'development'; // 默认环境
-
-    // 检查 --env 或 -e 参数
-    if (longEnvIndex !== -1 && process.argv[longEnvIndex + 1]) {
-        envInput = process.argv[longEnvIndex + 1];
-    } else if (shortEnvIndex !== -1 && process.argv[shortEnvIndex + 1]) {
-        envInput = process.argv[shortEnvIndex + 1];
-    } else if (process.env.NODE_ENV) {
-        // 如果设置了 NODE_ENV 环境变量
-        envInput = process.env.NODE_ENV;
-    }
-
-    // 解析环境名称（支持前缀匹配）
-    const envName = resolveEnvName(envInput);
-    const envFile = `.env.${envName}`;
-
-    // 过滤掉 --env/-e 参数（已通过 --env-file 处理）
-    const filteredArgs = process.argv.slice(2).filter((arg, i, arr) => {
-        if (arg === '--env' || arg === '-e') return false;
-        if (arr[i - 1] === '--env' || arr[i - 1] === '-e') return false;
-        return true;
-    });
-
-    // 启动子进程，使用指定的环境文件
-    const proc = Bun.spawn(['bun', 'run', `--env-file=${envFile}`, entryFile, ...filteredArgs], {
-        cwd: process.cwd(),
-        stdio: ['inherit', 'inherit', 'inherit'],
-        env: {
-            // 不继承父进程的环境变量，只使用以下变量
-            BEFLY_SUBPROCESS: '1', // 标记为子进程
-            NODE_ENV: envName, // 设置 NODE_ENV
-            PATH: process.env.PATH, // 保留 PATH
-            SYSTEMROOT: process.env.SYSTEMROOT, // Windows 需要
-            TEMP: process.env.TEMP, // Windows 需要
-            TMP: process.env.TMP // Windows 需要
-        }
-    });
-
-    // 等待子进程结束并退出（父进程不会返回）
-    process.exit(await proc.exited);
-}

package/commands/dev.ts

@@ -1,80 +0,0 @@
-/**
- * Dev 命令 - 启动开发服务器
- */
-
-import { join } from 'pathe';
-import { existsSync, mkdirSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { Befly } from '../main.js';
-import { getProjectRoot } from './util.js';
-
-interface DevOptions {
-    port: string;
-    host: string;
-    sync: boolean;
-    verbose: boolean;
-}
-
-export async function devCommand(options: DevOptions) {
-    try {
-        const projectRoot = getProjectRoot();
-
-        // 验证是否在 Befly 项目目录下
-        const packageJsonPath = join(projectRoot, 'package.json');
-        if (!existsSync(packageJsonPath)) {
-            Logger.error('未找到 package.json 文件，请确保在项目目录下');
-            process.exit(1);
-        }
-
-        // 检查并创建 logs 目录
-        const logsDir = join(projectRoot, 'logs');
-        if (!existsSync(logsDir)) {
-            mkdirSync(logsDir, { recursive: true });
-            Logger.info('已创建 logs 目录');
-        }
-
-        // 设置环境变量
-        process.env.NODE_ENV = 'development';
-        process.env.APP_PORT = options.port;
-        process.env.APP_HOST = options.host;
-
-        if (options.verbose) {
-            process.env.LOG_DEBUG = '1';
-        }
-
-        Logger.info('正在启动开发服务器...\n');
-        Logger.info(`端口: ${options.port}`);
-        Logger.info(`主机: ${options.host}`);
-        Logger.info(`环境: development\n`);
-
-        // 检查环境变量文件
-        const envFile = join(projectRoot, '.env.development');
-        if (existsSync(envFile)) {
-            Logger.info(`环境变量文件: .env.development\n`);
-        }
-
-        // 直接启动 Befly 实例
-        const app = new Befly();
-        const server = await app.listen();
-
-        // 设置信号处理，确保优雅关闭
-        const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];
-        signals.forEach((signal) => {
-            process.on(signal, async () => {
-                Logger.info(`\n收到 ${signal} 信号，正在关闭开发服务器...`);
-                try {
-                    server.stop(true);
-                    Logger.info('开发服务器已关闭');
-                    process.exit(0);
-                } catch (error) {
-                    Logger.error('关闭开发服务器失败:', error);
-                    process.exit(1);
-                }
-            });
-        });
-    } catch (error) {
-        Logger.error('启动开发服务器失败:');
-        console.error(error);
-        process.exit(1);
-    }
-}

package/commands/start.ts

@@ -1,92 +0,0 @@
-/**
- * Start 命令 - 启动生产服务器
- */
-
-import { join } from 'pathe';
-import { existsSync, mkdirSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { ClusterManager } from '../lifecycle/cluster.js';
-import { Befly } from '../main.js';
-import { getProjectRoot } from './util.js';
-
-interface StartOptions {
-    port: string;
-    host: string;
-    cluster?: string; // 集群模式：数字或 'max'
-}
-
-export async function startCommand(options: StartOptions) {
-    try {
-        const projectRoot = getProjectRoot();
-
-        // 验证是否在项目目录下
-        const packageJsonPath = join(projectRoot, 'package.json');
-        if (!existsSync(packageJsonPath)) {
-            Logger.error('未找到 package.json 文件，请确保在项目目录下');
-            process.exit(1);
-        }
-
-        // 检查并创建 logs 目录
-        const logsDir = join(projectRoot, 'logs');
-        if (!existsSync(logsDir)) {
-            mkdirSync(logsDir, { recursive: true });
-            Logger.info('已创建 logs 目录');
-        }
-
-        // 设置生产环境变量
-        process.env.NODE_ENV = 'production';
-        process.env.APP_PORT = options.port;
-        process.env.APP_HOST = options.host;
-
-        // 检查是否使用集群模式
-        if (options.cluster) {
-            // 集群模式
-            const instances = options.cluster === 'max' ? 'max' : parseInt(options.cluster);
-
-            const clusterManager = new ClusterManager({
-                instances,
-                startPort: parseInt(options.port),
-                host: options.host,
-                projectRoot
-            });
-
-            await clusterManager.start();
-        } else {
-            // 单进程模式
-            Logger.info('正在启动生产服务器...\n');
-            Logger.info(`端口: ${options.port}`);
-            Logger.info(`主机: ${options.host}`);
-            Logger.info(`环境: production\n`);
-
-            // 检查环境变量文件
-            const envFile = join(projectRoot, '.env.production');
-            if (existsSync(envFile)) {
-                Logger.info(`环境变量文件: .env.production\n`);
-            }
-
-            // 直接启动 Befly 实例
-            const app = new Befly();
-            const server = await app.listen();
-
-            // 设置信号处理，确保优雅关闭
-            const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];
-            signals.forEach((signal) => {
-                process.on(signal, async () => {
-                    Logger.info(`\n收到 ${signal} 信号，正在关闭生产服务器...`);
-                    try {
-                        server.stop(true);
-                        Logger.info('生产服务器已关闭');
-                        process.exit(0);
-                    } catch (error) {
-                        Logger.error('关闭生产服务器失败:', error);
-                        process.exit(1);
-                    }
-                });
-            });
-        }
-    } catch (error) {
-        Logger.error('启动失败:');
-        console.error(error);
-        process.exit(1);
-    }
-}

package/lifecycle/cluster-worker.ts

@@ -1,49 +0,0 @@
-/**
- * Cluster Worker 入口
- * 由 ClusterManager 启动的子进程入口文件
- */
-
-import { Befly } from '../main.js';
-import { Logger } from '../lib/logger.js';
-
-// 启动 Befly 实例
-const app = new Befly();
-const server = await app.listen();
-
-// Bun 原生信号处理：当收到 SIGTERM/SIGINT 时优雅关闭
-const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT'];
-
-signals.forEach((signal) => {
-    process.on(signal, async () => {
-        const workerId = process.env.CLUSTER_WORKER_ID || 'unknown';
-        Logger.info(`Worker ${workerId} 收到 ${signal} 信号，正在关闭...`);
-
-        try {
-            // Bun Server 的 stop() 方法：关闭服务器
-            // 参数 true 表示强制关闭（不等待现有连接）
-            server.stop(true);
-            Logger.info(`Worker ${workerId} HTTP 服务器已关闭`);
-
-            // 给予短暂时间让资源清理完成
-            await Bun.sleep(100);
-
-            process.exit(0);
-        } catch (error) {
-            Logger.error(`Worker ${workerId} 关闭失败:`, error);
-            process.exit(1);
-        }
-    });
-});
-
-// 处理未捕获的异常，防止进程意外退出
-process.on('uncaughtException', (error) => {
-    const workerId = process.env.CLUSTER_WORKER_ID || 'unknown';
-    Logger.error(`Worker ${workerId} 发生未捕获异常:`, error);
-    // 不退出进程，让 ClusterManager 决定是否重启
-});
-
-process.on('unhandledRejection', (reason) => {
-    const workerId = process.env.CLUSTER_WORKER_ID || 'unknown';
-    Logger.error(`Worker ${workerId} 发生未处理的 Promise 拒绝:`, reason);
-    // 不退出进程，让 ClusterManager 决定是否重启
-});

package/lifecycle/cluster.ts

@@ -1,254 +0,0 @@
-/**
- * Cluster Manager - 集群管理器
- * 负责多进程启动、自动重启、优雅关闭
- */
-
-import { join } from 'pathe';
-import type { Subprocess } from 'bun';
-import { Logger } from '../lib/logger.js';
-import { Befly } from '../main.js';
-
-export interface ClusterOptions {
-    /** 实例数量（数字或 'max'） */
-    instances: number | 'max';
-    /** 起始端口 */
-    startPort: number;
-    /** 主机地址 */
-    host: string;
-    /** 项目根目录 */
-    projectRoot: string;
-    /** 环境变量 */
-    env?: Record<string, string>;
-}
-
-interface WorkerInfo {
-    id: number;
-    port: number;
-    process: Subprocess;
-    restartCount: number;
-    lastRestartTime: number;
-}
-
-export class ClusterManager {
-    private workers: Map<number, WorkerInfo> = new Map();
-    private isShuttingDown = false;
-    private readonly MAX_RESTARTS = 10; // 最大重启次数
-    private readonly RESTART_DELAY = 1000; // 重启延迟（毫秒）
-    private readonly RESTART_WINDOW = 60000; // 重启计数窗口（1分钟）
-
-    constructor(private options: ClusterOptions) {}
-
-    /**
-     * 启动集群
-     */
-    async start(): Promise<void> {
-        const instances = this.getInstanceCount();
-        const { startPort, host } = this.options;
-
-        Logger.info(`启动集群模式: ${instances} 个实例\n`);
-        Logger.info(`端口范围: ${startPort} - ${startPort + instances - 1}`);
-        Logger.info(`主机地址: ${host}`);
-        Logger.info(`环境: production\n`);
-
-        // 启动所有 Worker
-        for (let i = 0; i < instances; i++) {
-            const port = startPort + i;
-            this.spawnWorker(i, port);
-        }
-
-        // 监听进程信号
-        this.setupSignalHandlers();
-
-        Logger.info(`集群启动成功！\n`);
-        this.printWorkerStatus();
-    }
-
-    /**
-     * 获取实例数量
-     */
-    private getInstanceCount(): number {
-        const { instances } = this.options;
-
-        if (instances === 'max') {
-            return navigator.hardwareConcurrency || 4;
-        }
-
-        const count = typeof instances === 'string' ? parseInt(instances) : instances;
-
-        if (isNaN(count) || count < 1) {
-            Logger.warn(`无效的实例数量 "${instances}"，使用默认值 4`);
-            return 4;
-        }
-
-        return count;
-    }
-
-    /**
-     * 启动单个 Worker
-     */
-    private spawnWorker(id: number, port: number): void {
-        const { projectRoot, host, env = {} } = this.options;
-
-        Logger.info(`启动 Worker ${id} (端口 ${port})...`);
-
-        // 使用内置的 worker 入口文件
-        const workerFile = join(import.meta.dir, 'cluster-worker.ts');
-
-        const proc = Bun.spawn(['bun', 'run', '--env-file=.env.production', workerFile], {
-            cwd: projectRoot,
-            stdout: 'inherit',
-            stderr: 'inherit',
-            stdin: 'inherit',
-            env: {
-                ...process.env,
-                ...env,
-                NODE_ENV: 'production',
-                APP_PORT: port.toString(),
-                APP_HOST: host,
-                CLUSTER_MODE: '1',
-                CLUSTER_WORKER_ID: id.toString(),
-                CLUSTER_INSTANCES: this.getInstanceCount().toString(),
-                FORCE_COLOR: '1'
-            }
-        });
-
-        // 保存 Worker 信息
-        this.workers.set(id, {
-            id,
-            port,
-            process: proc,
-            restartCount: 0,
-            lastRestartTime: 0
-        });
-
-        // 监听进程退出
-        this.watchWorker(id, port);
-    }
-
-    /**
-     * 监听 Worker 退出并自动重启
-     */
-    private async watchWorker(id: number, port: number): Promise<void> {
-        const worker = this.workers.get(id);
-        if (!worker) return;
-
-        const exitCode = await worker.process.exited;
-
-        // 如果正在关闭，不重启
-        if (this.isShuttingDown) {
-            Logger.info(`Worker ${id} (端口 ${port}) 已退出`);
-            return;
-        }
-
-        Logger.warn(`Worker ${id} (端口 ${port}) 异常退出，退出码: ${exitCode}`);
-
-        // 检查重启次数
-        if (!this.canRestart(worker)) {
-            Logger.error(`Worker ${id} 重启次数过多，停止重启`);
-            return;
-        }
-
-        // 延迟重启
-        Logger.info(`${this.RESTART_DELAY / 1000} 秒后重启 Worker ${id}...`);
-        await Bun.sleep(this.RESTART_DELAY);
-
-        // 更新重启计数
-        this.updateRestartCount(worker);
-
-        // 重新启动
-        this.spawnWorker(id, port);
-    }
-
-    /**
-     * 检查是否可以重启
-     */
-    private canRestart(worker: WorkerInfo): boolean {
-        const now = Date.now();
-        const timeSinceLastRestart = now - worker.lastRestartTime;
-
-        // 如果距离上次重启超过窗口期，重置计数
-        if (timeSinceLastRestart > this.RESTART_WINDOW) {
-            worker.restartCount = 0;
-        }
-
-        return worker.restartCount < this.MAX_RESTARTS;
-    }
-
-    /**
-     * 更新重启计数
-     */
-    private updateRestartCount(worker: WorkerInfo): void {
-        worker.restartCount++;
-        worker.lastRestartTime = Date.now();
-    }
-
-    /**
-     * 设置信号处理器
-     */
-    private setupSignalHandlers(): void {
-        const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGHUP'];
-
-        signals.forEach((signal) => {
-            process.on(signal, () => {
-                this.gracefulShutdown(signal);
-            });
-        });
-    }
-
-    /**
-     * 优雅关闭
-     */
-    private async gracefulShutdown(signal: NodeJS.Signals): Promise<void> {
-        if (this.isShuttingDown) return;
-        this.isShuttingDown = true;
-
-        Logger.info(`\n收到 ${signal} 信号，正在关闭集群...`);
-
-        // 向所有 Worker 发送 SIGTERM
-        for (const [id, worker] of this.workers.entries()) {
-            Logger.info(`关闭 Worker ${id} (端口 ${worker.port})...`);
-            try {
-                worker.process.kill('SIGTERM');
-            } catch (error) {
-                Logger.warn(`无法向 Worker ${id} 发送 SIGTERM:`, error);
-            }
-        }
-
-        // 等待所有进程退出，最多 3 秒（Bun 的 server.stop() 很快）
-        const timeout = setTimeout(() => {
-            Logger.warn('等待超时（3秒），强制关闭所有 Worker');
-            for (const worker of this.workers.values()) {
-                try {
-                    worker.process.kill('SIGKILL');
-                } catch (error) {
-                    // 忽略 SIGKILL 失败（进程可能已退出）
-                }
-            }
-            // 强制退出主进程
-            setTimeout(() => process.exit(1), 500);
-        }, 3000);
-
-        try {
-            // 等待所有进程退出
-            await Promise.all(Array.from(this.workers.values()).map((w) => w.process.exited));
-            clearTimeout(timeout);
-            Logger.info('集群已安全关闭');
-            process.exit(0);
-        } catch (error) {
-            clearTimeout(timeout);
-            Logger.error('等待 Worker 退出时发生错误:', error);
-            process.exit(1);
-        }
-    }
-
-    /**
-     * 打印 Worker 状态
-     */
-    private printWorkerStatus(): void {
-        Logger.info('Worker 列表:');
-        for (const worker of this.workers.values()) {
-            Logger.info(`  - Worker ${worker.id}: http://${this.options.host}:${worker.port}`);
-        }
-        Logger.info('');
-    }
-}