befly 3.5.6 → 3.6.0

package/checks/conflict.ts

@@ -1,351 +0,0 @@
-/**
- * 资源冲突检测
- * 在系统启动前检测表名、API 路由、插件名等资源是否存在冲突
- */
-
-import { relative, basename } from 'pathe';
-import { existsSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { projectPluginDir, coreTableDir, projectTableDir, projectApiDir } from '../paths.js';
-import { scanAddons, getAddonDir, addonDirExists } from '../util.js';
-
-/**
- * 保留名称配置
- */
-const RESERVED_NAMES = {
-    tablePrefix: ['sys_'],
-    plugins: ['db', 'logger', 'redis', 'tool'],
-    addonNames: ['app', 'api']
-} as const;
-
-/**
- * 资源注册表
- */
-interface ResourceRegistry {
-    tables: Map<string, string>; // 表名 -> 来源
-    routes: Map<string, string>; // 路由 -> 来源
-    plugins: Map<string, string>; // 插件名 -> 来源
-}
-
-/**
- * 冲突检测结果
- */
-interface ConflictResult {
-    hasConflicts: boolean;
-    conflicts: string[];
-}
-
-/**
- * 收集核心插件
- */
-async function collectCorePlugins(registry: ResourceRegistry): Promise<void> {
-    // 检查插件目录是否存在
-    if (!existsSync(projectPluginDir)) {
-        return;
-    }
-
-    try {
-        const glob = new Bun.Glob('*.ts');
-        for await (const file of glob.scan({
-            cwd: projectPluginDir,
-            onlyFiles: true,
-            absolute: true
-        })) {
-            const pluginName = basename(file).replace(/\.ts$/, '');
-            if (pluginName.startsWith('_')) continue;
-
-            if (registry.plugins.has(pluginName)) {
-                Logger.warn(`核心插件 "${pluginName}" 重复定义`);
-            } else {
-                registry.plugins.set(pluginName, 'core');
-            }
-        }
-    } catch (error: any) {
-        Logger.error('收集插件时出错:', error);
-    }
-}
-
-/**
- * 收集 addon 资源
- */
-async function collectAddonResources(addonName: string, registry: ResourceRegistry): Promise<string[]> {
-    const conflicts: string[] = [];
-
-    // 检查 addon 名称是否使用保留名称
-    if (RESERVED_NAMES.addonNames.includes(addonName.toLowerCase())) {
-        conflicts.push(`组件名称 "${addonName}" 使用了保留名称，保留名称包括: ${RESERVED_NAMES.addonNames.join(', ')}`);
-        return conflicts;
-    }
-
-    // 收集 addon 表定义
-    if (addonDirExists(addonName, 'tables')) {
-        const addonTablesDir = getAddonDir(addonName, 'tables');
-        const glob = new Bun.Glob('*.json');
-
-        for await (const file of glob.scan({
-            cwd: addonTablesDir,
-            onlyFiles: true,
-            absolute: true
-        })) {
-            const fileName = basename(file, '.json');
-            if (fileName.startsWith('_')) continue;
-
-            try {
-                const tableDefine = await Bun.file(file).json();
-                const tableName = tableDefine.tableName || `${addonName}_${fileName}`;
-
-                // 检查是否使用保留前缀
-                if (RESERVED_NAMES.tablePrefix.some((prefix) => tableName.startsWith(prefix))) {
-                    conflicts.push(`组件 ${addonName} 表 "${tableName}" 使用了保留前缀，保留前缀包括: ${RESERVED_NAMES.tablePrefix.join(', ')}`);
-                    continue;
-                }
-
-                // 检查是否与已有表冲突
-                if (registry.tables.has(tableName)) {
-                    conflicts.push(`组件 ${addonName} 表 "${tableName}" 与 ${registry.tables.get(tableName)} 冲突`);
-                } else {
-                    registry.tables.set(tableName, `组件${addonName}`);
-                }
-            } catch (error: any) {
-                // 表定义解析错误会在 table.ts 中处理，这里跳过
-            }
-        }
-    }
-
-    // 收集 addon API 路由
-    if (addonDirExists(addonName, 'apis')) {
-        const addonApisDir = getAddonDir(addonName, 'apis');
-        const glob = new Bun.Glob('**/*.ts');
-
-        for await (const file of glob.scan({
-            cwd: addonApisDir,
-            onlyFiles: true,
-            absolute: true
-        })) {
-            const apiPath = relative(addonApisDir, file).replace(/\.ts$/, '');
-            if (apiPath.indexOf('_') !== -1) continue;
-
-            try {
-                const api = (await import(file)).default;
-                const route = `${(api.method || 'POST').toUpperCase()}/api/${addonName}/${apiPath}`;
-
-                // 检查是否使用保留路由前缀 /api
-                if (route.includes('/api/api/') || route.includes('/api/api')) {
-                    conflicts.push(`组件 [${addonName}] 路由 "${route}" 使用了保留路径前缀 "/api"`);
-                    continue;
-                }
-
-                // 检查是否与已有路由冲突
-                if (registry.routes.has(route)) {
-                    conflicts.push(`组件 [${addonName}] 路由 "${route}" 与 ${registry.routes.get(route)} 冲突`);
-                } else {
-                    registry.routes.set(route, `组件${addonName}`);
-                }
-            } catch (error: any) {
-                // API 加载错误会在 loader.ts 中处理，这里跳过
-            }
-        }
-    }
-
-    // 收集 addon 插件
-    if (addonDirExists(addonName, 'plugins')) {
-        const addonPluginsDir = getAddonDir(addonName, 'plugins');
-        const glob = new Bun.Glob('*.ts');
-
-        for await (const file of glob.scan({
-            cwd: addonPluginsDir,
-            onlyFiles: true,
-            absolute: true
-        })) {
-            const fileName = basename(file).replace(/\.ts$/, '');
-            if (fileName.startsWith('_')) continue;
-
-            // Addon 插件使用点号命名空间
-            const pluginName = `${addonName}.${fileName}`;
-
-            // 检查是否使用保留名称（检测核心插件名或点号前缀是保留名称）
-            const isReserved = RESERVED_NAMES.plugins.includes(pluginName) || (pluginName.includes('.') && RESERVED_NAMES.plugins.includes(pluginName.split('.')[0]));
-            if (isReserved) {
-                conflicts.push(`组件 ${addonName} 插件 "${pluginName}" 使用了保留名称，保留名称包括: ${RESERVED_NAMES.plugins.join(', ')}`);
-                continue;
-            }
-
-            // 检查是否与已有插件冲突
-            if (registry.plugins.has(pluginName)) {
-                conflicts.push(`组件 [${addonName}] 插件 "${pluginName}" 与 ${registry.plugins.get(pluginName)} 冲突`);
-            } else {
-                registry.plugins.set(pluginName, `组件${addonName}`);
-            }
-        }
-    }
-
-    return conflicts;
-}
-
-/**
- * 收集用户资源
- */
-async function collectUserResources(registry: ResourceRegistry): Promise<string[]> {
-    const conflicts: string[] = [];
-
-    // 收集用户表定义
-    const userTablesDir = projectTableDir;
-    if (existsSync(userTablesDir)) {
-        try {
-            const glob = new Bun.Glob('*.json');
-            for await (const file of glob.scan({
-                cwd: userTablesDir,
-                onlyFiles: true,
-                absolute: true
-            })) {
-                const fileName = basename(file, '.json');
-                if (fileName.startsWith('_')) continue;
-
-                try {
-                    const tableDefine = await Bun.file(file).json();
-                    const tableName = tableDefine.tableName || fileName;
-
-                    // 检查是否使用保留前缀
-                    if (RESERVED_NAMES.tablePrefix.some((prefix) => tableName.startsWith(prefix))) {
-                        conflicts.push(`用户表 "${tableName}" 使用了保留前缀，保留前缀包括: ${RESERVED_NAMES.tablePrefix.join(', ')}`);
-                        continue;
-                    }
-
-                    // 检查是否与已有表冲突
-                    if (registry.tables.has(tableName)) {
-                        conflicts.push(`用户表 "${tableName}" 与 ${registry.tables.get(tableName)} 冲突`);
-                    } else {
-                        registry.tables.set(tableName, 'user');
-                    }
-                } catch (error: any) {
-                    // 表定义解析错误会在 table.ts 中处理，这里跳过
-                }
-            }
-        } catch (error: any) {
-            Logger.error('收集用户表定义时出错:', error);
-        }
-    }
-
-    // 收集用户 API 路由
-    const userApisDir = projectApiDir;
-    if (existsSync(userApisDir)) {
-        try {
-            const glob = new Bun.Glob('**/*.ts');
-            for await (const file of glob.scan({
-                cwd: userApisDir,
-                onlyFiles: true,
-                absolute: true
-            })) {
-                const apiPath = relative(userApisDir, file).replace(/\.ts$/, '');
-                if (apiPath.indexOf('_') !== -1) continue;
-
-                try {
-                    const api = (await import(file)).default;
-                    const route = `${(api.method || 'POST').toUpperCase()}/api/${apiPath}`;
-
-                    // 检查是否使用保留路由前缀 /api
-                    if (apiPath.startsWith('api/') || apiPath === 'api') {
-                        conflicts.push(`用户路由 "${route}" 使用了保留路径前缀 "/api"`);
-                        continue;
-                    }
-
-                    // 检查是否与已有路由冲突
-                    if (registry.routes.has(route)) {
-                        conflicts.push(`用户路由 "${route}" 与 ${registry.routes.get(route)} 冲突`);
-                    } else {
-                        registry.routes.set(route, 'user');
-                    }
-                } catch (error: any) {
-                    // API 加载错误会在 loader.ts 中处理，这里跳过
-                }
-            }
-        } catch (error: any) {
-            Logger.error('收集用户 API 路由时出错:', error);
-        }
-    }
-
-    // 收集用户插件
-    const userPluginsDir = projectPluginDir;
-    if (existsSync(userPluginsDir)) {
-        try {
-            const glob = new Bun.Glob('*.ts');
-            for await (const file of glob.scan({
-                cwd: userPluginsDir,
-                onlyFiles: true,
-                absolute: true
-            })) {
-                const pluginName = basename(file).replace(/\.ts$/, '');
-                if (pluginName.startsWith('_')) continue;
-
-                // 检查是否使用保留名称（检测核心插件名或点号前缀是保留名称）
-                const isReserved = RESERVED_NAMES.plugins.includes(pluginName) || (pluginName.includes('.') && RESERVED_NAMES.plugins.includes(pluginName.split('.')[0]));
-                if (isReserved) {
-                    conflicts.push(`用户插件 "${pluginName}" 使用了保留名称，保留名称包括: ${RESERVED_NAMES.plugins.join(', ')}`);
-                    continue;
-                }
-
-                // 检查是否与已有插件冲突
-                if (registry.plugins.has(pluginName)) {
-                    conflicts.push(`用户插件 "${pluginName}" 与 ${registry.plugins.get(pluginName)} 冲突`);
-                } else {
-                    registry.plugins.set(pluginName, 'user');
-                }
-            }
-        } catch (error: any) {
-            Logger.error('收集用户插件时出错:', error);
-        }
-    }
-
-    return conflicts;
-}
-
-/**
- * 执行资源冲突检测
- */
-export default async function checkConflict(): Promise<boolean> {
-    try {
-        // 初始化资源注册表
-        const registry: ResourceRegistry = {
-            tables: new Map(),
-            routes: new Map(),
-            plugins: new Map()
-        };
-
-        const allConflicts: string[] = [];
-
-        // 1. 收集核心插件
-        await collectCorePlugins(registry);
-
-        // 2. 收集 addon 资源
-        const addons = scanAddons();
-        for (const addon of addons) {
-            const addonConflicts = await collectAddonResources(addon, registry);
-            allConflicts.push(...addonConflicts);
-        }
-
-        // 3. 收集用户资源
-        const userConflicts = await collectUserResources(registry);
-        allConflicts.push(...userConflicts);
-
-        // 4. 报告冲突
-        if (allConflicts.length > 0) {
-            Logger.warn('检测到资源冲突:');
-            allConflicts.forEach((conflict, index) => {
-                Logger.warn(`  ${index + 1}. ${conflict}`);
-            });
-            Logger.warn('请解决以上冲突后再启动服务器');
-            return false;
-        }
-
-        // 5. 统计信息
-        Logger.info(`资源冲突检测通过 ✓`);
-        Logger.info(`  - 表: ${registry.tables.size} 个`);
-        Logger.info(`  - 路由: ${registry.routes.size} 个`);
-        Logger.info(`  - 插件: ${registry.plugins.size} 个`);
-
-        return true;
-    } catch (error: any) {
-        Logger.error('资源冲突检测时发生错误:', error);
-        return false;
-    }
-}

package/checks/table.ts

@@ -1,250 +0,0 @@
-/**
- * 表规则检查器 - TypeScript 版本
- * 验证表定义文件的格式和规则
- */
-
-import { basename } from 'pathe';
-import { Logger } from '../lib/logger.js';
-import { parseRule } from '../util.js';
-import { projectTableDir } from '../paths.js';
-import { scanAddons, getAddonDir } from '../util.js';
-
-/**
- * 表文件信息接口
- */
-interface TableFileInfo {
-    /** 表文件路径 */
-    file: string;
-    /** 文件类型：project（项目）或 addon（组件） */
-    type: 'project' | 'addon';
-    /** 如果是 addon 类型，记录 addon 名称 */
-    addonName?: string;
-}
-
-/**
- * 保留字段列表
- */
-const RESERVED_FIELDS = ['id', 'created_at', 'updated_at', 'deleted_at', 'state'] as const;
-
-/**
- * 允许的字段类型
- */
-const FIELD_TYPES = ['string', 'number', 'text', 'array_string', 'array_text'] as const;
-
-/**
- * 小驼峰命名正则
- * 可选：以下划线开头（用于特殊文件，如通用字段定义）
- * 必须以小写字母开头，后续可包含小写/数字，或多个 [大写+小写/数字] 片段
- * 示例：userTable、testCustomers、common
- */
-const LOWER_CAMEL_CASE_REGEX = /^_?[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
-
-/**
- * 字段名称正则
- * 必须为中文、数字、字母、下划线、短横线、空格
- */
-const FIELD_NAME_REGEX = /^[\u4e00-\u9fa5a-zA-Z0-9 _-]+$/;
-
-/**
- * VARCHAR 最大长度限制
- */
-const MAX_VARCHAR_LENGTH = 65535;
-
-/**
- * 检查表定义文件
- * @returns 检查是否通过
- */
-export default async function (): Promise<boolean> {
-    try {
-        const tablesGlob = new Bun.Glob('*.json');
-
-        // 统计信息
-        let totalFiles = 0;
-        let totalRules = 0;
-        let validFiles = 0;
-        let invalidFiles = 0;
-
-        // 收集所有表文件
-        const allTableFiles: TableFileInfo[] = [];
-
-        // 收集项目表字段定义文件
-        for await (const file of tablesGlob.scan({
-            cwd: projectTableDir,
-            absolute: true,
-            onlyFiles: true
-        })) {
-            allTableFiles.push({ file, type: 'project' });
-        }
-
-        // 收集 addon 表字段定义文件
-        const addons = scanAddons();
-        for (const addonName of addons) {
-            const addonTablesDir = getAddonDir(addonName, 'tables');
-
-            try {
-                for await (const file of tablesGlob.scan({
-                    cwd: addonTablesDir,
-                    absolute: true,
-                    onlyFiles: true
-                })) {
-                    allTableFiles.push({ file, type: 'addon', addonName });
-                }
-            } catch (error) {
-                // addon 的 tables 目录可能不存在，跳过
-            }
-        }
-
-        // 合并进行验证逻辑
-        for (const { file, type, addonName } of allTableFiles) {
-            totalFiles++;
-            const fileName = basename(file);
-            const fileBaseName = basename(file, '.json');
-            const fileType = type === 'project' ? '项目' : `组件${addonName}`;
-
-            try {
-                // 1) 文件名小驼峰校验
-                if (!LOWER_CAMEL_CASE_REGEX.test(fileBaseName)) {
-                    Logger.warn(`${fileType}表 ${fileName} 文件名必须使用小驼峰命名（例如 testCustomers.json）`);
-                    // 命名不合规，记录错误并计为无效文件，继续下一个文件
-                    invalidFiles++;
-                    continue;
-                }
-
-                // 读取并解析 JSON 文件
-                const table = await Bun.file(file).json();
-                let fileValid = true;
-                let fileRules = 0;
-
-                // 检查 table 中的每个验证规则
-                for (const [colKey, rule] of Object.entries(table)) {
-                    if (typeof rule !== 'string') {
-                        Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 规则必须为字符串`);
-                        fileValid = false;
-                        continue;
-                    }
-
-                    // 验证规则格式
-                    try {
-                        fileRules++;
-                        totalRules++;
-
-                        // 检查是否使用了保留字段
-                        if (RESERVED_FIELDS.includes(colKey as any)) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件包含保留字段 ${colKey}，` + `不能在表定义中使用以下字段: ${RESERVED_FIELDS.join(', ')}`);
-                            fileValid = false;
-                        }
-
-                        // 使用 parseRule 解析字段规则
-                        let parsed;
-                        try {
-                            parsed = parseRule(rule);
-                        } catch (error: any) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段规则解析失败：${error.message}`);
-                            fileValid = false;
-                            continue;
-                        }
-
-                        const { name: fieldName, type: fieldType, min: fieldMin, max: fieldMax, default: fieldDefault, index: fieldIndex, regex: fieldRegx } = parsed;
-
-                        // 第1个值：名称必须为中文、数字、字母、下划线、短横线、空格
-                        if (!FIELD_NAME_REGEX.test(fieldName)) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段名称 "${fieldName}" 格式错误，` + `必须为中文、数字、字母、下划线、短横线、空格`);
-                            fileValid = false;
-                        }
-
-                        // 第2个值：字段类型必须为string,number,text,array_string,array_text之一
-                        if (!FIELD_TYPES.includes(fieldType as any)) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 字段类型 "${fieldType}" 格式错误，` + `必须为${FIELD_TYPES.join('、')}之一`);
-                            fileValid = false;
-                        }
-
-                        // 第3/4个值：需要是 null 或 数字
-                        if (!(fieldMin === null || typeof fieldMin === 'number')) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 格式错误，必须为null或数字`);
-                            fileValid = false;
-                        }
-                        if (!(fieldMax === null || typeof fieldMax === 'number')) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大值 "${fieldMax}" 格式错误，必须为null或数字`);
-                            fileValid = false;
-                        }
-
-                        // 约束：当最小值与最大值均为数字时，要求最小值 <= 最大值
-                        if (fieldMin !== null && fieldMax !== null) {
-                            if (fieldMin > fieldMax) {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最小值 "${fieldMin}" 不能大于最大值 "${fieldMax}"`);
-                                fileValid = false;
-                            }
-                        }
-
-                        // 第6个值：是否创建索引必须为0或1
-                        if (fieldIndex !== 0 && fieldIndex !== 1) {
-                            Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 索引标识 "${fieldIndex}" 格式错误，必须为0或1`);
-                            fileValid = false;
-                        }
-
-                        // 第7个值：必须为null或正则表达式（parseRule已经验证过了）
-                        // parseRule 已经将正则字符串转换为 RegExp 或 null，这里不需要再验证
-
-                        // 第4个值与类型联动校验 + 默认值规则
-                        if (fieldType === 'text') {
-                            // text：min/max 必须为 null，默认值必须为 'null'
-                            if (fieldMin !== null) {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最小值必须为 null，当前为 "${fieldMin}"`);
-                                fileValid = false;
-                            }
-                            if (fieldMax !== null) {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 的 text 类型最大长度必须为 null，当前为 "${fieldMax}"`);
-                                fileValid = false;
-                            }
-                            if (fieldDefault !== 'null') {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 text 类型，默认值必须为 null，当前为 "${fieldDefault}"`);
-                                fileValid = false;
-                            }
-                        } else if (fieldType === 'string' || fieldType === 'array') {
-                            if (fieldMax === null || typeof fieldMax !== 'number') {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 ${fieldType} 类型，` + `最大长度必须为数字，当前为 "${fieldMax}"`);
-                                fileValid = false;
-                            } else if (fieldMax > MAX_VARCHAR_LENGTH) {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 最大长度 ${fieldMax} 越界，` + `${fieldType} 类型长度必须在 1..${MAX_VARCHAR_LENGTH} 范围内`);
-                                fileValid = false;
-                            }
-                        } else if (fieldType === 'number') {
-                            if (fieldDefault !== 'null' && typeof fieldDefault !== 'number') {
-                                Logger.warn(`${fileType}表 ${fileName} 文件 ${colKey} 为 number 类型，` + `默认值必须为数字或null，当前为 "${fieldDefault}"`);
-                                fileValid = false;
-                            }
-                        }
-                    } catch (error: any) {
-                        // 单个字段规则解析失败已在上面处理
-                    }
-                }
-
-                if (fileValid) {
-                    validFiles++;
-                    // Logger.info(`${fileType}表 ${fileName} 验证通过（${fileRules} 个字段）`);
-                } else {
-                    invalidFiles++;
-                }
-            } catch (error: any) {
-                Logger.error(`${fileType}表 ${fileName} 解析失败: ${error.message}`);
-                invalidFiles++;
-            }
-        }
-
-        // 输出统计信息
-        // Logger.info(`  总文件数: ${totalFiles}`);
-        // Logger.info(`  总规则数: ${totalRules}`);
-        // Logger.info(`  通过文件: ${validFiles}`);
-        // Logger.info(`  失败文件: ${invalidFiles}`);
-
-        if (invalidFiles > 0) {
-            Logger.warn(`表定义检查失败，请修复上述错误后重试`);
-            return false;
-        } else {
-            return true;
-        }
-    } catch (error: any) {
-        Logger.error('数据表定义检查过程中出错:', error);
-        return false;
-    }
-}

package/commands/index.ts

@@ -1,73 +0,0 @@
-/**
- * Sync 命令实现
- */
-
-import { join } from 'pathe';
-import { existsSync } from 'node:fs';
-import { Logger } from '../lib/logger.js';
-import { getProjectRoot } from './util.js';
-
-// ========== 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);
-        }
-
-        Logger.info('正在同步数据库表...');
-
-        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) {
-            Logger.success('数据库同步完成');
-        } else {
-            Logger.error('数据库同步失败');
-            process.exit(1);
-        }
-    } catch (error) {
-        Logger.error('同步失败:');
-        console.error(error);
-        process.exit(1);
-    }
-}
-
-// ========== 导出同步命令 ==========
-export { syncApiCommand } from './syncApi.js';
-export { syncMenuCommand } from './syncMenu.js';
-export { syncDevCommand } from './syncDev.js';