befly 3.5.1 → 3.5.2

package/lifecycle/checker.ts

@@ -46,20 +46,15 @@ export class Checker {
                         const conflictCheckTime = calcPerfTime(conflictCheckStart);
 
                         if (typeof conflictResult !== 'boolean') {
-                            Logger.warn(`核心检查 conflict.ts 返回值必须为 true 或 false，当前为 ${typeof conflictResult}，耗时: ${conflictCheckTime}`);
+                            Logger.warn(`核心检查 conflict.ts 返回值必须为 true 或 false，当前为 ${typeof conflictResult}`);
                             stats.failedChecks++;
                         } else if (conflictResult === true) {
                             stats.passedChecks++;
-                            Logger.info(`核心检查 conflict.ts 通过，耗时: ${conflictCheckTime}`);
                         } else {
-                            Logger.warn(`核心检查未通过: conflict.ts，耗时: ${conflictCheckTime}`);
+                            Logger.warn(`核心检查未通过: conflict.ts`);
                             stats.failedChecks++;
                             // 资源冲突检测失败，立即终止
-                            Logger.warn('资源冲突检测失败，无法继续启动', {
-                                totalChecks: stats.totalChecks,
-                                passedChecks: stats.passedChecks,
-                                failedChecks: stats.failedChecks
-                            });
+                            Logger.warn('资源冲突检测失败，无法继续启动');
                             process.exit(1);
                         }
                     }
@@ -88,8 +83,6 @@ export class Checker {
                 const { path: checkDir, type } = checkConfig;
                 const addonName = 'addonName' in checkConfig ? checkConfig.addonName : undefined;
                 const checkTypeLabel = type === 'core' ? '核心' : type === 'project' ? '项目' : `组件${addonName}`;
-                Logger.info(`开始执行${checkTypeLabel}检查，目录: ${checkDir}`);
-
                 for await (const file of glob.scan({
                     cwd: checkDir,
                     onlyFiles: true,
@@ -118,18 +111,16 @@ export class Checker {
 
                             // 检查返回值是否为 boolean
                             if (typeof checkResult !== 'boolean') {
-                                Logger.warn(`${checkTypeLabel}检查 ${fileName} 返回值必须为 true 或 false，当前为 ${typeof checkResult}，耗时: ${singleCheckTime}`);
+                                Logger.warn(`${checkTypeLabel}检查 ${fileName} 返回值必须为 true 或 false，当前为 ${typeof checkResult}`);
                                 stats.failedChecks++;
                             } else if (checkResult === true) {
                                 stats.passedChecks++;
-                                Logger.info(`${checkTypeLabel}检查 ${fileName} 通过，耗时: ${singleCheckTime}`);
                             } else {
-                                Logger.warn(`${checkTypeLabel}检查未通过: ${fileName}，耗时: ${singleCheckTime}`);
+                                Logger.warn(`${checkTypeLabel}检查未通过: ${fileName}`);
                                 stats.failedChecks++;
                             }
                         } else {
-                            const singleCheckTime = calcPerfTime(singleCheckStart);
-                            Logger.warn(`${checkTypeLabel}检查文件 ${fileName} 未找到 default 导出的检查函数，耗时: ${singleCheckTime}`);
+                            Logger.warn(`${checkTypeLabel}检查文件 ${fileName} 未找到 default 导出的检查函数`);
                             stats.failedChecks++;
                         }
                     } catch (error: any) {
@@ -143,19 +134,11 @@ export class Checker {
             const totalCheckTime = calcPerfTime(checkStartTime);
 
             // 输出检查结果统计
-            Logger.info(`系统检查完成! 总耗时: ${totalCheckTime}，总检查数: ${stats.totalChecks}, 通过: ${stats.passedChecks}, 失败: ${stats.failedChecks}`);
-
             if (stats.failedChecks > 0) {
-                Logger.error('统检查失败，无法继续启动', {
-                    totalChecks: stats.totalChecks,
-                    passedChecks: stats.passedChecks,
-                    failedChecks: stats.failedChecks
-                });
+                Logger.error(`✗ 系统检查失败: ${stats.failedChecks}/${stats.totalChecks}，耗时: ${totalCheckTime}`);
                 process.exit(1);
             } else if (stats.totalChecks > 0) {
-                Logger.info(`所有系统检查通过!`);
-            } else {
-                Logger.info(`未执行任何检查`);
+                Logger.info(`✓ 系统检查通过: ${stats.passedChecks}/${stats.totalChecks}，耗时: ${totalCheckTime}`);
             }
         } catch (error: any) {
             Logger.error('执行系统检查时发生错误', error);

package/lifecycle/lifecycle.ts

@@ -39,7 +39,6 @@ export class Lifecycle {
      */
     async start(appContext: BeflyContext, callback?: (server: Server) => void): Promise<Server> {
         const serverStartTime = Bun.nanoseconds();
-        Logger.info('开始启动 Befly 服务器...');
 
         // 1. 执行系统检查
         await Checker.run();
@@ -52,7 +51,7 @@ export class Lifecycle {
 
         // 4. 启动 HTTP 服务器
         const totalStartupTime = calcPerfTime(serverStartTime);
-        Logger.info(`服务器启动准备完成，总耗时: ${totalStartupTime}`);
+        Logger.info(`✓ 服务器启动准备完成，总耗时: ${totalStartupTime}`);
 
         return await Bootstrap.start(
             {
@@ -70,63 +69,35 @@ export class Lifecycle {
      * 包括 core APIs、addon APIs 和 app APIs
      */
     private async loadAllApis(): Promise<void> {
-        Logger.info('========== 开始加载所有 API 路由 ==========');
-        const totalLoadStart = Bun.nanoseconds();
-
         // 1. 加载 Core APIs
-        Logger.info('========== 开始加载核心 APIs ==========');
-        const coreApiLoadStart = Bun.nanoseconds();
         try {
             await Loader.loadApis('core', this.apiRoutes, { where: 'core' });
-            const coreApiLoadTime = calcPerfTime(coreApiLoadStart);
-            Logger.info(`========== 核心 APIs 加载完成，耗时: ${coreApiLoadTime} ==========`);
         } catch (error: any) {
-            const coreApiLoadTime = calcPerfTime(coreApiLoadStart);
-            Logger.error(`核心 APIs 加载失败，耗时: ${coreApiLoadTime}`, error);
+            Logger.error(`核心 APIs 加载失败`, error);
             throw error;
         }
 
         // 2. 加载 addon APIs
         const addons = scanAddons();
-        Logger.info(`扫描到 ${addons.length} 个 addon: ${addons.join(', ')}`);
 
         for (const addon of addons) {
-            const addonLoadStart = Bun.nanoseconds();
             const hasApis = addonDirExists(addon, 'apis');
-            Logger.info(`[组件 ${addon}] APIs 目录存在: ${hasApis}`);
-
             if (hasApis) {
-                Logger.info(`[组件 ${addon}] ===== 开始加载 APIs =====`);
                 try {
                     await Loader.loadApis(addon, this.apiRoutes, { where: 'addon', addonName: addon });
-                    const addonLoadTime = calcPerfTime(addonLoadStart);
-                    Logger.info(`[组件 ${addon}] ===== APIs 加载完成，耗时: ${addonLoadTime} =====`);
                 } catch (error: any) {
-                    const addonLoadTime = calcPerfTime(addonLoadStart);
-                    Logger.error(`[组件 ${addon}] APIs 加载失败，耗时: ${addonLoadTime}`, error);
-                    throw error; // 重新抛出错误，让上层处理
+                    Logger.error(`[组件 ${addon}] APIs 加载失败`, error);
+                    throw error;
                 }
             }
         }
 
-        Logger.info('========== 组件 APIs 全部加载完成 ==========');
-
         // 3. 加载用户 APIs
-        Logger.info('========== 开始加载用户 APIs ==========');
-
-        const userApiLoadStart = Bun.nanoseconds();
         try {
-            // 加载 app APIs
             await Loader.loadApis('app', this.apiRoutes, { where: 'app' });
-            const userApiLoadTime = calcPerfTime(userApiLoadStart);
-            Logger.info(`========== 用户 APIs 加载完成，耗时: ${userApiLoadTime} ==========`);
         } catch (error: any) {
-            const userApiLoadTime = calcPerfTime(userApiLoadStart);
-            Logger.error(`用户 APIs 加载失败，耗时: ${userApiLoadTime}`, error);
+            Logger.error(`用户 APIs 加载失败`, error);
             throw error;
         }
-
-        const totalLoadTime = calcPerfTime(totalLoadStart);
-        Logger.info(`========== 所有 API 路由加载完成！总耗时: ${totalLoadTime} ==========`);
     }
 }

package/lifecycle/loader.ts

@@ -107,18 +107,11 @@ export class Loader {
                 if (fileName.startsWith('_')) continue;
 
                 try {
-                    const importStart = Bun.nanoseconds();
-                    Logger.debug(`准备导入核心插件: ${fileName}`);
                     const plugin = await importWithTimeout(file);
-                    const importTime = calcPerfTime(importStart);
-                    Logger.debug(`核心插件 ${fileName} 导入成功，耗时: ${importTime}`);
-
                     const pluginInstance = plugin.default;
                     pluginInstance.pluginName = fileName;
                     corePlugins.push(pluginInstance);
                     loadedPluginNames.add(fileName); // 记录已加载的核心插件名称
-
-                    Logger.info(`核心插件 ${fileName} 导入耗时: ${importTime}`);
                 } catch (err: any) {
                     hadCorePluginError = true;
                     Logger.error(`核心插件 ${fileName} 导入失败`, error);
@@ -126,10 +119,6 @@ export class Loader {
                 }
             }
             const corePluginsScanTime = calcPerfTime(corePluginsScanStart);
-            Logger.info(`核心插件扫描完成，耗时: ${corePluginsScanTime}，共找到 ${corePlugins.length} 个插件`);
-
-            Logger.debug(`调试模式已开启`);
-            Logger.debug(`开始排序核心插件，插件列表: ${corePlugins.map((p) => p.pluginName).join(', ')}`);
 
             const sortedCorePlugins = sortPlugins(corePlugins);
             if (sortedCorePlugins === false) {
@@ -137,42 +126,26 @@ export class Loader {
                 process.exit(1);
             }
 
-            Logger.debug(`核心插件排序完成，顺序: ${sortedCorePlugins.map((p) => p.pluginName).join(' -> ')}`);
-
             // 初始化核心插件
             const corePluginsInitStart = Bun.nanoseconds();
-            Logger.info(`开始初始化核心插件...`);
             for (const plugin of sortedCorePlugins) {
                 try {
-                    Logger.debug(`准备初始化核心插件: ${plugin.pluginName}`);
-
                     befly.pluginLists.push(plugin);
-
-                    Logger.debug(`检查插件 ${plugin.pluginName} 是否有 onInit 方法: ${typeof plugin?.onInit === 'function'}`);
-
                     if (typeof plugin?.onInit === 'function') {
-                        Logger.debug(`开始执行插件 ${plugin.pluginName} 的 onInit 方法`);
-
                         const pluginInitStart = Bun.nanoseconds();
                         befly.appContext[plugin.pluginName] = await plugin?.onInit(befly.appContext);
                         const pluginInitTime = calcPerfTime(pluginInitStart);
-
-                        Logger.debug(`插件 ${plugin.pluginName} 初始化完成，耗时: ${pluginInitTime}`);
                     } else {
                         befly.appContext[plugin.pluginName] = {};
-                        Logger.debug(`插件 ${plugin.pluginName} 没有 onInit 方法，跳过初始化`);
                     }
-
-                    Logger.info(`核心插件 ${plugin.pluginName} 初始化成功`);
                 } catch (error: any) {
                     hadCorePluginError = true;
                     Logger.error(`核心插件 ${plugin.pluginName} 初始化失败`, error);
-
                     process.exit(1);
                 }
             }
             const corePluginsInitTime = calcPerfTime(corePluginsInitStart);
-            Logger.info(`核心插件初始化完成，耗时: ${corePluginsInitTime}`);
+            Logger.info(`✓ 核心插件加载完成: ${corePlugins.length} 个，耗时: ${corePluginsScanTime}`);
 
             // 扫描 addon 插件目录
             const addons = scanAddons();
@@ -194,23 +167,17 @@ export class Loader {
 
                         // 检查是否已经加载了同名插件
                         if (loadedPluginNames.has(pluginFullName)) {
-                            Logger.info(`跳过组件插件 ${pluginFullName}，因为同名插件已存在`);
                             continue;
                         }
 
                         try {
                             const importStart = Bun.nanoseconds();
-                            Logger.debug(`准备导入 addon 插件: ${addon}.${fileName}`);
                             const plugin = await importWithTimeout(file);
                             const importTime = calcPerfTime(importStart);
-                            Logger.debug(`Addon 插件 ${addon}.${fileName} 导入成功，耗时: ${importTime}`);
-
                             const pluginInstance = plugin.default;
                             pluginInstance.pluginName = pluginFullName;
                             addonPlugins.push(pluginInstance);
                             loadedPluginNames.add(pluginFullName);
-
-                            Logger.info(`组件${addon} ${fileName} 导入耗时: ${importTime}`);
                         } catch (err: any) {
                             hadAddonPluginError = true;
                             Logger.error(`组件${addon} ${fileName} 导入失败`, error);
@@ -219,7 +186,6 @@ export class Loader {
                     }
                 }
                 const addonPluginsScanTime = calcPerfTime(addonPluginsScanStart);
-                Logger.info(`组件插件扫描完成，耗时: ${addonPluginsScanTime}，共找到 ${addonPlugins.length} 个插件`);
 
                 const sortedAddonPlugins = sortPlugins(addonPlugins);
                 if (sortedAddonPlugins === false) {
@@ -230,39 +196,30 @@ export class Loader {
                 } else {
                     // 初始化组件插件
                     const addonPluginsInitStart = Bun.nanoseconds();
-                    Logger.info(`开始初始化组件插件...`);
                     for (const plugin of sortedAddonPlugins) {
                         try {
-                            Logger.debug(`准备初始化组件插件: ${plugin.pluginName}`);
-
                             befly.pluginLists.push(plugin);
 
                             if (typeof plugin?.onInit === 'function') {
-                                Logger.debug(`开始执行组件插件 ${plugin.pluginName} 的 onInit 方法`);
-
                                 const pluginInitStart = Bun.nanoseconds();
                                 befly.appContext[plugin.pluginName] = await plugin?.onInit(befly.appContext);
                                 const pluginInitTime = calcPerfTime(pluginInitStart);
-
-                                Logger.debug(`组件插件 ${plugin.pluginName} 初始化完成，耗时: ${pluginInitTime}`);
                             } else {
                                 befly.appContext[plugin.pluginName] = {};
                             }
-
-                            Logger.info(`组件插件 ${plugin.pluginName} 初始化成功`);
                         } catch (error: any) {
                             hadAddonPluginError = true;
                             Logger.error(`组件插件 ${plugin.pluginName} 初始化失败`, error);
                         }
                     }
                     const addonPluginsInitTime = calcPerfTime(addonPluginsInitStart);
-                    Logger.info(`组件插件初始化完成，耗时: ${addonPluginsInitTime}`);
+                    Logger.info(`✓ 组件插件加载完成: ${addonPlugins.length} 个，耗时: ${addonPluginsScanTime}`);
                 }
             }
 
             // 扫描用户插件目录
             if (!existsSync(projectPluginDir)) {
-                Logger.info(`项目插件目录不存在，跳过加载: ${projectPluginDir}`);
+                // 项目插件目录不存在，跳过
             } else {
                 const userPluginsScanStart = Bun.nanoseconds();
                 for await (const file of glob.scan({
@@ -275,30 +232,20 @@ export class Loader {
 
                     // 检查是否已经加载了同名的核心插件
                     if (loadedPluginNames.has(fileName)) {
-                        Logger.info(`跳过用户插件 ${fileName}，因为同名的核心插件已存在`);
                         continue;
                     }
 
                     try {
-                        const importStart = Bun.nanoseconds();
-                        Logger.debug(`准备导入用户插件: ${fileName}`);
                         const plugin = await importWithTimeout(file);
-                        const importTime = calcPerfTime(importStart);
-                        Logger.debug(`用户插件 ${fileName} 导入成功，耗时: ${importTime}`);
-
                         const pluginInstance = plugin.default;
                         pluginInstance.pluginName = fileName;
                         userPlugins.push(pluginInstance);
-
-                        Logger.info(`用户插件 ${fileName} 导入耗时: ${importTime}`);
                     } catch (err: any) {
                         hadUserPluginError = true;
                         Logger.error(`用户插件 ${fileName} 导入失败`, error);
                         process.exit(1);
                     }
                 }
-                const userPluginsScanTime = calcPerfTime(userPluginsScanStart);
-                Logger.info(`用户插件扫描完成，耗时: ${userPluginsScanTime}，共找到 ${userPlugins.length} 个插件`);
             }
 
             const sortedUserPlugins = sortPlugins(userPlugins);
@@ -314,64 +261,42 @@ export class Loader {
             // 初始化用户插件
             if (userPlugins.length > 0) {
                 const userPluginsInitStart = Bun.nanoseconds();
-                Logger.info(`开始初始化用户插件...`);
                 for (const plugin of sortedUserPlugins) {
                     try {
-                        Logger.debug(`准备初始化用户插件: ${plugin.pluginName}`);
-
                         befly.pluginLists.push(plugin);
 
                         if (typeof plugin?.onInit === 'function') {
-                            Logger.debug(`开始执行用户插件 ${plugin.pluginName} 的 onInit 方法`);
-
-                            const pluginInitStart = Bun.nanoseconds();
                             befly.appContext[plugin.pluginName] = await plugin?.onInit(befly.appContext);
-                            const pluginInitTime = calcPerfTime(pluginInitStart);
-
-                            Logger.debug(`用户插件 ${plugin.pluginName} 初始化完成，耗时: ${pluginInitTime}`);
                         } else {
                             befly.appContext[plugin.pluginName] = {};
                         }
-
-                        Logger.info(`用户插件 ${plugin.pluginName} 初始化成功`);
                     } catch (error: any) {
                         hadUserPluginError = true;
                         Logger.error(`用户插件 ${plugin.pluginName} 初始化失败`, error);
                     }
                 }
                 const userPluginsInitTime = calcPerfTime(userPluginsInitStart);
-                Logger.info(`用户插件初始化完成，耗时: ${userPluginsInitTime}`);
+                Logger.info(`✓ 用户插件加载完成: ${sortedUserPlugins.length} 个，耗时: ${userPluginsInitTime}`);
             }
 
             const totalLoadTime = calcPerfTime(loadStartTime);
             const totalPluginCount = sortedCorePlugins.length + addonPlugins.length + sortedUserPlugins.length;
-            Logger.info(`插件加载完成! 总耗时: ${totalLoadTime}，共加载 ${totalPluginCount} 个插件`);
+            Logger.info(`✓ 所有插件加载完成: ${totalPluginCount} 个，总耗时: ${totalLoadTime}`);
 
             // 核心插件失败 → 关键错误，必须退出
             if (hadCorePluginError) {
-                Logger.warn('核心插件加载失败，无法继续启动', {
-                    corePluginCount: sortedCorePlugins.length,
-                    totalPluginCount
-                });
+                Logger.warn('核心插件加载失败，无法继续启动');
                 process.exit(1);
             }
 
             // Addon 插件失败 → 警告，可以继续运行
             if (hadAddonPluginError) {
-                Logger.info({
-                    level: 'INFO',
-                    msg: '部分 Addon 插件加载失败，但不影响核心功能',
-                    addonPluginCount: addonPlugins.length
-                });
+                Logger.warn('部分 Addon 插件加载失败，但不影响核心功能');
             }
 
             // 用户插件失败 → 警告，可以继续运行
             if (hadUserPluginError) {
-                Logger.info({
-                    level: 'INFO',
-                    msg: '部分用户插件加载失败，但不影响核心功能',
-                    userPluginCount: sortedUserPlugins.length
-                });
+                Logger.warn('部分用户插件加载失败，但不影响核心功能');
             }
         } catch (error: any) {
             Logger.error('加载插件时发生错误', error);
@@ -407,7 +332,6 @@ export class Loader {
 
             // 检查目录是否存在
             if (!existsSync(apiDir)) {
-                Logger.info(`${dirDisplayName}接口目录不存在，跳过加载: ${apiDir}`);
                 return;
             }
 
@@ -429,17 +353,9 @@ export class Loader {
                 const singleApiStart = Bun.nanoseconds();
 
                 try {
-                    Logger.debug(`[${dirDisplayName}] 准备导入 API 文件: ${apiPath}`);
-                    Logger.debug(`[${dirDisplayName}] 文件绝对路径: ${file}`);
-
                     const importStart = Bun.nanoseconds();
                     const api = (await importWithTimeout(file)).default;
                     const importTime = calcPerfTime(importStart);
-
-                    Logger.debug(`[${dirDisplayName}] API 文件导入成功: ${apiPath}，耗时: ${importTime}`);
-
-                    Logger.debug(`[${dirDisplayName}] 开始验证 API 属性: ${apiPath}`);
-
                     // 验证必填属性：name 和 handler
                     if (typeof api.name !== 'string' || api.name.trim() === '') {
                         throw new Error(`接口 ${apiPath} 的 name 属性必须是非空字符串`);
@@ -472,9 +388,6 @@ export class Loader {
                     if (api.required && api.required.some((item: any) => typeof item !== 'string')) {
                         throw new Error(`接口 ${apiPath} 的 required 属性必须是字符串数组`);
                     }
-
-                    Logger.debug(`[${dirDisplayName}] API 属性验证通过: ${apiPath}`);
-
                     // 构建路由：
                     // - core 接口: /api/core/{apiPath}
                     // - addon 接口: /api/addon/{addonName}/{apiPath}
@@ -488,22 +401,19 @@ export class Loader {
                     }
                     apiRoutes.set(api.route, api);
 
-                    const singleApiTime = calcPerfTime(singleApiStart);
                     loadedApis++;
-                    Logger.debug(`[${dirDisplayName}] API 注册成功 - 名称: ${api.name}, 路由: ${api.route}, 耗时: ${singleApiTime}`);
                 } catch (error: any) {
-                    const singleApiTime = calcPerfTime(singleApiStart);
                     failedApis++;
 
                     // 记录详细错误信息
-                    Logger.error(`[${dirDisplayName}] 接口 ${apiPath} 加载失败 (${singleApiTime})`, error);
+                    Logger.error(`[${dirDisplayName}] 接口 ${apiPath} 加载失败`, error);
 
                     process.exit(1);
                 }
             }
 
             const totalLoadTime = calcPerfTime(loadStartTime);
-            Logger.info(`${dirDisplayName}接口加载完成! 总耗时: ${totalLoadTime}，总数: ${totalApis}, 成功: ${loadedApis}, 失败: ${failedApis}`);
+            Logger.info(`✓ ${dirDisplayName}接口加载完成: ${loadedApis}/${totalApis}，耗时: ${totalLoadTime}`);
 
             // 检查是否有加载失败的 API（理论上不会到达这里，因为上面已经 critical 退出）
             if (failedApis > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.5.1",
+    "version": "3.5.2",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -75,10 +75,8 @@
     },
     "dependencies": {
         "chalk": "^5.6.2",
-        "commander": "^14.0.2",
         "es-toolkit": "^1.41.0",
-        "inquirer": "^12.10.0",
         "pathe": "^2.0.3"
     },
-    "gitHead": "bb6847f91fb09704ec47fdae750b3296419d5085"
+    "gitHead": "0896911e340ee0e7ee9d65a28d0809a3365ee9f4"
 }

package/commands/build.ts

@@ -1,62 +0,0 @@
-/**
- * Build 命令 - 构建项目
- */
-
-import { join } from 'pathe';
-import { existsSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { getProjectRoot } from './util.js';
-
-interface BuildOptions {
-    outdir: string;
-    minify: boolean;
-    sourcemap: boolean;
-}
-
-export async function buildCommand(options: BuildOptions) {
-    try {
-        const projectRoot = getProjectRoot();
-
-        // 验证是否在项目目录下
-        const packageJsonPath = join(projectRoot, 'package.json');
-        if (!existsSync(packageJsonPath)) {
-            Logger.error('未找到 package.json 文件，请确保在项目目录下');
-            process.exit(1);
-        }
-
-        // 使用内置默认入口文件
-        const entryFile = join(import.meta.dir, '..', 'entry.ts');
-
-        Logger.info('正在构建项目...');
-
-        const args = ['build', entryFile, '--outdir', options.outdir, '--target', 'bun'];
-
-        if (options.minify) {
-            args.push('--minify');
-        }
-
-        if (options.sourcemap) {
-            args.push('--sourcemap');
-        }
-
-        const proc = Bun.spawn(['bun', ...args], {
-            cwd: projectRoot,
-            stdout: 'pipe',
-            stderr: 'pipe'
-        });
-
-        await proc.exited;
-
-        if (proc.exitCode === 0) {
-            Logger.success('项目构建完成');
-            Logger.success(`输出目录: ${options.outdir}`);
-        } else {
-            Logger.error('项目构建失败');
-            process.exit(1);
-        }
-    } catch (error) {
-        Logger.error('构建失败:');
-        console.error(error);
-        process.exit(1);
-    }
-}