befly 3.2.0 → 3.3.0

package/commands/index.ts

@@ -0,0 +1,252 @@
+/**
+ * Build、Start、Sync、Addon、SyncApi、SyncMenu、SyncDev 命令实现
+ */
+
+import { join } from 'pathe';
+import { existsSync } from 'node:fs';
+import ora from 'ora';
+import { Logger } from '../lib/logger.js';
+
+function getProjectRoot(): string {
+    let current = process.cwd();
+    const path = require('node:path');
+    while (current !== path.parse(current).root) {
+        if (existsSync(join(current, 'package.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}
+
+// ========== Build 命令 ==========
+interface BuildOptions {
+    outdir: string;
+    minify: boolean;
+    sourcemap: boolean;
+}
+
+export async function buildCommand(options: BuildOptions) {
+    try {
+        const projectRoot = getProjectRoot();
+        const mainFile = join(projectRoot, 'main.ts');
+
+        if (!existsSync(mainFile)) {
+            Logger.error('未找到 main.ts 文件');
+            process.exit(1);
+        }
+
+        const spinner = ora({
+            text: '正在构建项目...',
+            color: 'cyan',
+            spinner: 'dots'
+        }).start();
+
+        const args = ['build', mainFile, '--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) {
+            spinner.succeed('项目构建完成');
+            Logger.success(`输出目录: ${options.outdir}`);
+        } else {
+            spinner.fail('项目构建失败');
+            process.exit(1);
+        }
+    } catch (error) {
+        Logger.error('构建失败:');
+        console.error(error);
+        process.exit(1);
+    }
+}
+
+// ========== Start 命令 ==========
+interface StartOptions {
+    port: string;
+    host: string;
+}
+
+export async function startCommand(options: StartOptions) {
+    try {
+        const projectRoot = getProjectRoot();
+        const mainFile = join(projectRoot, 'main.ts');
+
+        if (!existsSync(mainFile)) {
+            Logger.error('未找到 main.ts 文件');
+            process.exit(1);
+        }
+
+        process.env.NODE_ENV = 'production';
+        process.env.APP_PORT = options.port;
+        process.env.APP_HOST = options.host;
+
+        Logger.info('正在启动生产服务器...\n');
+        Logger.info(`端口: ${options.port}`);
+        Logger.info(`主机: ${options.host}`);
+        Logger.info(`环境: production\n`);
+
+        const proc = Bun.spawn(['bun', 'run', mainFile], {
+            cwd: projectRoot,
+            stdout: 'inherit',
+            stderr: 'inherit',
+            stdin: 'inherit',
+            env: {
+                ...process.env,
+                FORCE_COLOR: '1'
+            }
+        });
+
+        await proc.exited;
+        process.exit(proc.exitCode || 0);
+    } catch (error) {
+        Logger.error('启动失败:');
+        console.error(error);
+        process.exit(1);
+    }
+}
+
+// ========== Sync 命令 ==========
+interface SyncOptions {
+    table?: string;
+    force: boolean;
+    dryRun: boolean;
+    drop: boolean;
+}
+
+export async function syncCommand(options: SyncOptions) {
+    try {
+        const projectRoot = getProjectRoot();
+        const syncScript = join(projectRoot, 'node_modules', 'befly', 'scripts', 'syncTable.ts');
+
+        if (!existsSync(syncScript)) {
+            Logger.error('未找到同步脚本，请确保已安装 befly');
+            process.exit(1);
+        }
+
+        const spinner = ora({
+            text: '正在同步数据库表...',
+            color: 'cyan',
+            spinner: 'dots'
+        }).start();
+
+        const args = ['run', syncScript];
+
+        if (options.table) {
+            args.push('--table', options.table);
+        }
+
+        if (options.force) {
+            args.push('--force');
+        }
+
+        if (options.dryRun) {
+            args.push('--dry-run');
+        }
+
+        if (options.drop) {
+            args.push('--drop');
+        }
+
+        const proc = Bun.spawn(['bun', ...args], {
+            cwd: projectRoot,
+            stdout: 'inherit',
+            stderr: 'inherit',
+            stdin: 'inherit'
+        });
+
+        await proc.exited;
+
+        if (proc.exitCode === 0) {
+            spinner.succeed('数据库同步完成');
+        } else {
+            spinner.fail('数据库同步失败');
+            process.exit(1);
+        }
+    } catch (error) {
+        Logger.error('同步失败:');
+        console.error(error);
+        process.exit(1);
+    }
+}
+
+// ========== Addon 命令 ==========
+export const addonCommand = {
+    async install(name: string, options: { source?: string }) {
+        const spinner = ora({
+            text: `正在安装插件: ${name}`,
+            color: 'cyan',
+            spinner: 'dots'
+        }).start();
+
+        try {
+            // TODO: 实现插件安装逻辑
+            // 1. 从 source 或默认源下载插件
+            // 2. 解压到 addons 目录
+            // 3. 安装插件依赖
+            // 4. 执行插件安装脚本
+
+            spinner.succeed(`插件 ${name} 安装成功`);
+        } catch (error) {
+            spinner.fail(`插件 ${name} 安装失败`);
+            throw error;
+        }
+    },
+
+    async uninstall(name: string, options: { keepData: boolean }) {
+        const spinner = ora({
+            text: `正在卸载插件: ${name}`,
+            color: 'cyan',
+            spinner: 'dots'
+        }).start();
+
+        try {
+            // TODO: 实现插件卸载逻辑
+            // 1. 执行插件卸载脚本
+            // 2. 删除插件文件
+            // 3. 可选：删除插件数据
+
+            spinner.succeed(`插件 ${name} 卸载成功`);
+        } catch (error) {
+            spinner.fail(`插件 ${name} 卸载失败`);
+            throw error;
+        }
+    },
+
+    async list() {
+        try {
+            const projectRoot = getProjectRoot();
+            const addonsDir = join(projectRoot, 'addons');
+
+            if (!existsSync(addonsDir)) {
+                Logger.info('未找到 addons 目录');
+                return;
+            }
+
+            // TODO: 读取已安装的插件列表
+            Logger.info('已安装的插件:\n');
+            Logger.info('(功能开发中)');
+        } catch (error) {
+            Logger.error('获取插件列表失败:');
+            console.error(error);
+        }
+    }
+};
+
+// ========== 导出新增的同步命令 ==========
+export { syncApiCommand } from './syncApi.js';
+export { syncMenuCommand } from './syncMenu.js';
+export { syncDevCommand } from './syncDev.js';

package/commands/script.ts

@@ -0,0 +1,308 @@
+/**
+ * Script 命令 - 列出并执行项目脚本
+ */
+
+import { join, dirname, parse, resolve, basename } from 'pathe';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { Glob } from 'bun';
+import inquirer from 'inquirer';
+import { Logger } from '../lib/logger.js';
+
+/**
+ * 脚本项接口
+ */
+interface ScriptItem {
+    /** 脚本名称 */
+    name: string;
+    /** 脚本来源 (core、project 或 addon 名称) */
+    source: string;
+    /** 显示名称 */
+    displayName: string;
+    /** 脚本完整路径 */
+    path: string;
+}
+
+/**
+ * 查找项目根目录（向上查找 package.json）
+ */
+function findProjectRoot(startDir: string): string | null {
+    let currentDir = startDir;
+    const root = parse(currentDir).root;
+
+    while (currentDir !== root) {
+        const packagePath = join(currentDir, 'package.json');
+        if (existsSync(packagePath)) {
+            return currentDir;
+        }
+        currentDir = dirname(currentDir);
+    }
+
+    return null;
+}
+
+/**
+ * 安全地列出目录下的所有 .ts 脚本文件
+ */
+function safeList(dir: string): string[] {
+    try {
+        if (!existsSync(dir)) {
+            return [];
+        }
+
+        const glob = new Glob('*.ts');
+        const files = Array.from(
+            glob.scanSync({
+                cwd: dir,
+                absolute: false,
+                onlyFiles: true,
+                dot: false
+            })
+        );
+
+        return files.map((f) => basename(f).replace(/\.ts$/, '')).sort();
+    } catch {
+        return [];
+    }
+}
+
+/**
+ * 扫描 CLI 自带的 scripts
+ */
+function scanCliScripts(): Array<{ scriptName: string; scriptPath: string }> {
+    const results: Array<{ scriptName: string; scriptPath: string }> = [];
+
+    try {
+        // 获取 CLI 包的根目录（当前文件在 commands 目录下）
+        const cliRoot = resolve(__dirname, '..');
+        const scriptsDir = join(cliRoot, 'scripts');
+
+        if (!existsSync(scriptsDir)) {
+            return results;
+        }
+
+        const scriptFiles = readdirSync(scriptsDir);
+
+        for (const file of scriptFiles) {
+            // 只处理直接子级的 .ts 文件
+            if (file.endsWith('.ts')) {
+                const scriptName = file.replace(/\.ts$/, '');
+                const scriptPath = join(scriptsDir, file);
+
+                // 确保是文件而不是目录
+                if (statSync(scriptPath).isFile()) {
+                    results.push({
+                        scriptName,
+                        scriptPath
+                    });
+                }
+            }
+        }
+    } catch {
+        // 静默失败
+    }
+
+    return results;
+}
+
+/**
+ * 扫描 node_modules/@befly/addon-* 下的 scripts
+ */
+function scanAddonScripts(projectRoot: string): Array<{ addonName: string; scriptName: string; scriptPath: string }> {
+    const results: Array<{ addonName: string; scriptName: string; scriptPath: string }> = [];
+
+    try {
+        const beflyAddonsDir = join(projectRoot, 'node_modules', '@befly');
+
+        if (!existsSync(beflyAddonsDir)) {
+            return results;
+        }
+
+        // 读取 @befly 目录下的所有 addon
+        const addonDirs = readdirSync(beflyAddonsDir);
+
+        for (const addonDir of addonDirs) {
+            // 只处理 addon-* 开头的目录
+            if (!addonDir.startsWith('addon-')) {
+                continue;
+            }
+
+            const scriptsDir = join(beflyAddonsDir, addonDir, 'scripts');
+
+            if (!existsSync(scriptsDir)) {
+                continue;
+            }
+
+            try {
+                const scriptFiles = readdirSync(scriptsDir);
+
+                for (const file of scriptFiles) {
+                    if (file.endsWith('.ts')) {
+                        const scriptName = file.replace(/\.ts$/, '');
+                        const scriptPath = join(scriptsDir, file);
+
+                        results.push({
+                            addonName: addonDir,
+                            scriptName,
+                            scriptPath
+                        });
+                    }
+                }
+            } catch {
+                // 忽略无法读取的目录
+            }
+        }
+    } catch (error) {
+        // 静默失败
+    }
+
+    return results;
+}
+
+/**
+ * 构建所有可用脚本的列表
+ */
+function buildScriptItems(projectRoot: string): ScriptItem[] {
+    const items: ScriptItem[] = [];
+
+    // CLI 脚本
+    const cliScripts = scanCliScripts();
+    for (const script of cliScripts) {
+        items.push({
+            name: script.scriptName,
+            source: 'cli',
+            displayName: `[CLI] ${script.scriptName}`,
+            path: script.scriptPath
+        });
+    }
+
+    // 项目脚本
+    const projectScriptsDir = join(projectRoot, 'scripts');
+    const projectList = safeList(projectScriptsDir);
+    for (const name of projectList) {
+        items.push({
+            name,
+            source: 'project',
+            displayName: `[Project] ${name}`,
+            path: resolve(projectScriptsDir, `${name}.ts`)
+        });
+    }
+
+    // Addon 脚本
+    const addonScripts = scanAddonScripts(projectRoot);
+    for (const addon of addonScripts) {
+        items.push({
+            name: addon.scriptName,
+            source: `addon:${addon.addonName}`,
+            displayName: `[${addon.addonName}] ${addon.scriptName}`,
+            path: addon.scriptPath
+        });
+    }
+
+    return items;
+}
+
+/**
+ * 运行脚本
+ */
+async function runScript(scriptPath: string, args: string[] = []): Promise<number> {
+    const bunExe = process.execPath || 'bun';
+    const child = Bun.spawn({
+        cmd: [bunExe, scriptPath, ...args],
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd: process.cwd(),
+        env: { ...process.env }
+    });
+
+    const code = await child.exited;
+    return code ?? 0;
+}
+
+/**
+ * Script 命令处理函数
+ */
+export async function scriptCommand(options: { dryRun?: boolean; plan?: boolean } = {}) {
+    try {
+        // 查找项目根目录
+        const projectRoot = findProjectRoot();
+        if (!projectRoot) {
+            Logger.error('未找到项目根目录（缺少 package.json）');
+            process.exit(1);
+        }
+
+        // 构建脚本列表
+        const items = buildScriptItems(projectRoot);
+
+        if (items.length === 0) {
+            Logger.warn('没有找到可用的脚本');
+            process.exit(0);
+        }
+
+        // 使用 inquirer 选择脚本
+        const { selectedScript } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'selectedScript',
+                message: '请选择要执行的脚本:',
+                choices: items.map((item) => ({
+                    name: item.displayName,
+                    value: item
+                })),
+                loop: false
+            }
+        ]);
+
+        // 询问是否添加 --plan 参数
+        let scriptArgs: string[] = [];
+        if (options.plan !== false) {
+            const { addPlan } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'addPlan',
+                    message: '是否添加 --plan 参数（预演模式）?',
+                    default: false
+                }
+            ]);
+
+            if (addPlan) {
+                scriptArgs.push('--plan');
+            }
+        }
+
+        // 预演模式
+        if (options.dryRun) {
+            Logger.info(`[预演模式] 将执行: ${selectedScript.displayName}`);
+            Logger.info(`[预演模式] 脚本路径: ${selectedScript.path}`);
+            if (scriptArgs.length > 0) {
+                Logger.info(`[预演模式] 参数: ${scriptArgs.join(' ')}`);
+            }
+            process.exit(0);
+        }
+
+        // 确认执行
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `确认执行 ${selectedScript.displayName}?`,
+                default: true
+            }
+        ]);
+
+        if (!confirm) {
+            Logger.info('已取消执行');
+            process.exit(0);
+        }
+
+        // 执行脚本
+        const argsInfo = scriptArgs.length > 0 ? ` (参数: ${scriptArgs.join(' ')})` : '';
+        Logger.info(`正在执行: ${selectedScript.displayName}${argsInfo}\n`);
+
+        const exitCode = await runScript(selectedScript.path, scriptArgs);
+        process.exit(exitCode);
+    } catch (error) {
+        if (error instanceof Error) {
+            Logger.error(`执行失败: ${error.message}`);
+        }
+        process.exit(1);
+    }
+}

package/commands/start.ts

@@ -0,0 +1,80 @@
+/**
+ * Start 命令 - 启动生产服务器
+ */
+
+import { join } from 'pathe';
+import { existsSync } from 'node:fs';
+import { Logger } from '../lib/logger.js';
+import { ClusterManager } from '../lifecycle/cluster.js';
+
+function getProjectRoot(): string {
+    let current = process.cwd();
+    const path = require('node:path');
+    while (current !== path.parse(current).root) {
+        if (existsSync(join(current, 'package.json'))) {
+            return current;
+        }
+        current = path.dirname(current);
+    }
+    return process.cwd();
+}
+
+interface StartOptions {
+    port: string;
+    host: string;
+    cluster?: string; // 集群模式：数字或 'max'
+}
+
+export async function startCommand(options: StartOptions) {
+    try {
+        const projectRoot = getProjectRoot();
+        const mainFile = join(projectRoot, 'main.ts');
+
+        if (!existsSync(mainFile)) {
+            Logger.error('未找到 main.ts 文件');
+            process.exit(1);
+        }
+
+        // 设置生产环境变量
+        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,
+                mainFile
+            });
+
+            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`);
+            }
+
+            // 直接导入并运行 main.ts（Bun 会自动加载 .env.production）
+            await import(mainFile);
+
+            // 注意：正常情况下不会执行到这里，因为 main.ts 会启动服务器并持续运行
+        }
+    } catch (error) {
+        Logger.error('启动失败:');
+        console.error(error);
+        process.exit(1);
+    }
+}