befly 3.5.1 → 3.5.2

package/commands/syncDb/index.ts

@@ -41,6 +41,21 @@ const globalCount: Record<string, number> = {
     indexDrop: 0
 };
 
+// 导出统计接口
+export interface SyncDbStats {
+    processedTables: number;
+    createdTables: number;
+    modifiedTables: number;
+    addFields: number;
+    nameChanges: number;
+    typeChanges: number;
+    minChanges: number;
+    maxChanges: number;
+    defaultChanges: number;
+    indexCreate: number;
+    indexDrop: number;
+}
+
 /**
  * 主同步函数
  *
@@ -49,15 +64,13 @@ const globalCount: Record<string, number> = {
  * 2. 建立数据库连接并检查版本
  * 3. 扫描表定义文件（核心表、项目表、addon表）
  * 4. 对比并应用表结构变更
- * 5. 输出统计信息
+ * 5. 返回统计信息
  */
-export const SyncDb = async (): Promise<void> => {
+export const SyncDb = async (): Promise<SyncDbStats> => {
     const perfTracker = new PerformanceTracker();
     const progressLogger = new ProgressLogger();
 
     try {
-        Logger.info('开始数据库表结构同步...');
-
         // 重置全局统计，避免多次调用累加
         for (const k of Object.keys(globalCount)) {
             if (typeof globalCount[k] === 'number') globalCount[k] = 0;
@@ -68,13 +81,11 @@ export const SyncDb = async (): Promise<void> => {
         if (!(await checkTable())) {
             throw new Error('表定义验证失败');
         }
-        Logger.info(`✓ 表定义验证完成，耗时: ${perfTracker.getPhaseTime('表定义验证')}`);
 
         // 阶段2：建立数据库连接并检查版本
         perfTracker.markPhase('数据库连接');
         sql = await Database.connectSql({ max: 1 });
         await ensureDbVersion(sql);
-        Logger.info(`✓ 数据库连接建立，耗时: ${perfTracker.getPhaseTime('数据库连接')}`);
 
         // 阶段3：扫描表定义文件
         perfTracker.markPhase('扫描表文件');
@@ -113,7 +124,6 @@ export const SyncDb = async (): Promise<void> => {
             }
         }
         perfTracker.finishPhase('扫描表文件');
-        Logger.info(`✓ 扫描完成，发现 ${totalTables} 个表定义文件，耗时: ${perfTracker.getPhaseTime('扫描表文件')}`);
 
         // 阶段4：处理表文件
         perfTracker.markPhase('同步处理');
@@ -132,7 +142,6 @@ export const SyncDb = async (): Promise<void> => {
 
                 // 跳过以下划线开头的文件（这些是公共字段规则，不是表定义）
                 if (fileName.startsWith('_')) {
-                    Logger.info(`跳过非表定义文件: ${fileName}.json`);
                     continue;
                 }
 
@@ -155,7 +164,6 @@ export const SyncDb = async (): Promise<void> => {
                 }
 
                 processedCount++;
-                progressLogger.logTableProgress(processedCount, totalTables, tableName, dirType);
 
                 const tableDefinition = await Bun.file(file).json();
                 const existsTable = await tableExists(sql!, tableName);
@@ -171,29 +179,21 @@ export const SyncDb = async (): Promise<void> => {
         }
 
         perfTracker.finishPhase('同步处理');
-        Logger.info(`✓ 表处理完成，耗时: ${perfTracker.getPhaseTime('同步处理')}`);
-
-        // 阶段5：显示统计信息
-        Logger.info('\n=== 同步统计信息 ===');
-        Logger.info(`总耗时: ${perfTracker.getTotalTime()}`);
-        Logger.info(`处理表总数: ${globalCount.processedTables}`);
-        Logger.info(`创建表: ${globalCount.createdTables}`);
-        Logger.info(`修改表: ${globalCount.modifiedTables}`);
-        Logger.info(`字段新增: ${globalCount.addFields}`);
-        Logger.info(`字段名称变更: ${globalCount.nameChanges}`);
-        Logger.info(`字段类型变更: ${globalCount.typeChanges}`);
-        Logger.info(`字段最小值变更: ${globalCount.minChanges}`);
-        Logger.info(`字段最大值变更: ${globalCount.maxChanges}`);
-        Logger.info(`字段默认值变更: ${globalCount.defaultChanges}`);
-        Logger.info(`索引新增: ${globalCount.indexCreate}`);
-        Logger.info(`索引删除: ${globalCount.indexDrop}`);
-
-        if (globalCount.processedTables === 0) {
-            Logger.warn('没有找到任何表定义文件');
-        }
 
-        // 输出性能统计
-        perfTracker.logStats();
+        // 返回统计信息
+        return {
+            processedTables: globalCount.processedTables,
+            createdTables: globalCount.createdTables,
+            modifiedTables: globalCount.modifiedTables,
+            addFields: globalCount.addFields,
+            nameChanges: globalCount.nameChanges,
+            typeChanges: globalCount.typeChanges,
+            minChanges: globalCount.minChanges,
+            maxChanges: globalCount.maxChanges,
+            defaultChanges: globalCount.defaultChanges,
+            indexCreate: globalCount.indexCreate,
+            indexDrop: globalCount.indexDrop
+        };
     } catch (error: any) {
         Logger.error(`数据库同步失败`, error);
         process.exit(1);

package/commands/syncDb.ts

@@ -6,14 +6,14 @@ import { Command } from 'commander';
 import { join } from 'pathe';
 import { existsSync } from 'node:fs';
 import { Logger } from '../lib/logger.js';
-import { SyncDb } from './syncDb/index.js';
+import { SyncDb, type SyncDbStats } from './syncDb/index.js';
 
 interface SyncDbOptions {
     table?: string;
     dryRun: boolean;
 }
 
-export async function syncDbCommand(options: SyncDbOptions) {
+export async function syncDbCommand(options: SyncDbOptions): Promise<SyncDbStats> {
     try {
         // 设置环境变量
         if (options.dryRun) {
@@ -24,9 +24,9 @@ export async function syncDbCommand(options: SyncDbOptions) {
             process.env.SYNC_TABLE = options.table;
         }
 
-        // 执行同步
-        await SyncDb();
-        Logger.info('数据库表结构同步完成');
+        // 执行同步并返回统计
+        const stats = await SyncDb();
+        return stats;
     } catch (error: any) {
         Logger.error('数据库同步失败:', error);
         process.exit(1);

package/commands/syncDev.ts

@@ -16,23 +16,26 @@ interface SyncDevOptions {
     plan?: boolean;
 }
 
+export interface SyncDevStats {
+    adminCount: number;
+    roleCount: number;
+    cachedRoles: number;
+}
+
 /**
  * SyncDev 命令主函数
  */
-export async function syncDevCommand(options: SyncDevOptions = {}) {
+export async function syncDevCommand(options: SyncDevOptions = {}): Promise<SyncDevStats> {
     try {
         if (options.plan) {
             Logger.info('[计划] 同步完成后将初始化/更新开发管理员账号（plan 模式不执行）');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         if (!Env.DEV_PASSWORD) {
-            Logger.warn('跳过开发管理员初始化：缺少 DEV_PASSWORD 配置');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
-        Logger.info('开始同步开发管理员账号...\n');
-
         // 连接数据库（SQL + Redis）
         await Database.connect();
 
@@ -41,22 +44,19 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
         // 检查 core_admin 表是否存在
         const existAdmin = await helper.tableExists('core_admin');
         if (!existAdmin) {
-            Logger.warn('跳过开发管理员初始化：未检测到 core_admin 表');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         // 检查 core_role 表是否存在
         const existRole = await helper.tableExists('core_role');
         if (!existRole) {
-            Logger.warn('跳过开发管理员初始化：未检测到 core_role 表');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         // 检查 core_menu 表是否存在
         const existMenu = await helper.tableExists('core_menu');
         if (!existMenu) {
-            Logger.warn('跳过开发管理员初始化：未检测到 core_menu 表');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         // 查询所有菜单 ID
@@ -66,12 +66,10 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
         });
 
         if (!allMenus || !Array.isArray(allMenus)) {
-            Logger.warn('查询菜单失败或菜单表为空');
-            return;
+            return { adminCount: 0, roleCount: 0, cachedRoles: 0 };
         }
 
         const menuIds = allMenus.length > 0 ? allMenus.map((m: any) => m.id).join(',') : '';
-        Logger.debug(`查询到 ${allMenus.length} 个菜单，ID 列表: ${menuIds || '(空)'}`);
 
         // 查询所有接口 ID
         const existApi = await helper.tableExists('core_api');
@@ -84,12 +82,7 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
 
             if (allApis && Array.isArray(allApis) && allApis.length > 0) {
                 apiIds = allApis.map((a: any) => a.id).join(',');
-                Logger.debug(`查询到 ${allApis.length} 个接口，ID 列表: ${apiIds}`);
-            } else {
-                Logger.info('未查询到接口数据');
             }
-        } else {
-            Logger.info('接口表不存在，跳过接口权限配置');
         }
 
         // 查询或创建 dev 角色
@@ -110,7 +103,6 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                     apis: apiIds
                 }
             });
-            Logger.info('dev 角色菜单和接口权限已更新');
         } else {
             // 创建 dev 角色
             const roleId = await helper.insData({
@@ -149,6 +141,7 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
             where: { email: Env.DEV_EMAIL }
         });
 
+        let isNew = false;
         if (existing) {
             // 更新现有账号
             await helper.updData({
@@ -156,26 +149,23 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                 where: { email: Env.DEV_EMAIL },
                 data: devData
             });
-            Logger.info(`✅ 开发管理员已更新：email=${Env.DEV_EMAIL}, username=dev, roleCode=dev, roleType=admin`);
         } else {
             // 插入新账号
             await helper.insData({
                 table: 'core_admin',
                 data: devData
             });
-            Logger.info(`✅ 开发管理员已初始化：email=${Env.DEV_EMAIL}, username=dev, roleCode=dev, roleType=admin`);
+            isNew = true;
         }
 
         // 缓存角色权限数据到 Redis
-        Logger.info('\n=== 缓存角色权限到 Redis ===');
+        let cachedRolesCount = 0;
         try {
             // 检查必要的表是否存在
             const apiTableExists = await helper.tableExists('core_api');
             const roleTableExists = await helper.tableExists('core_role');
 
-            if (!apiTableExists || !roleTableExists) {
-                Logger.warn('⚠️ 接口或角色表不存在，跳过角色权限缓存');
-            } else {
+            if (apiTableExists && roleTableExists) {
                 // 查询所有角色
                 const roles = await helper.getAll({
                     table: 'core_role',
@@ -189,7 +179,6 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                 });
 
                 const redis = Database.getRedis();
-                let cachedRoles = 0;
 
                 // 为每个角色缓存接口权限
                 for (const role of roles) {
@@ -216,16 +205,29 @@ export async function syncDevCommand(options: SyncDevOptions = {}) {
                     const result = await redis.sadd(redisKey, ...roleApiPaths);
 
                     if (result > 0) {
-                        cachedRoles++;
-                        Logger.debug(`   └ 角色 ${role.code}: ${result} 个接口`);
+                        cachedRolesCount++;
                     }
                 }
-
-                Logger.info(`✅ 已缓存 ${cachedRoles} 个角色的接口权限`);
             }
         } catch (error: any) {
-            Logger.error('⚠️ 角色权限缓存异常:', error);
+            // 忽略缓存错误
         }
+
+        // 获取统计数据
+        const allAdmins = await helper.getAll({
+            table: 'core_admin',
+            fields: ['id']
+        });
+        const allRoles = await helper.getAll({
+            table: 'core_role',
+            fields: ['id']
+        });
+
+        return {
+            adminCount: allAdmins.length,
+            roleCount: allRoles.length,
+            cachedRoles: cachedRolesCount
+        };
     } catch (error: any) {
         Logger.error('开发管理员同步失败:', error);
         process.exit(1);

package/commands/syncMenu.ts

@@ -34,6 +34,15 @@ interface MenuConfig {
     children?: MenuConfig[];
 }
 
+export interface SyncMenuStats {
+    totalMenus: number;
+    parentMenus: number;
+    childMenus: number;
+    created: number;
+    updated: number;
+    deleted: number;
+}
+
 /**
  * 读取菜单配置文件
  * 如果文件不存在或不是数组格式，返回空数组
@@ -41,7 +50,6 @@ interface MenuConfig {
 async function readMenuConfig(filePath: string): Promise<MenuConfig[]> {
     try {
         if (!existsSync(filePath)) {
-            Logger.warn(`菜单配置文件不存在: ${filePath}，使用空数组`);
             return [];
         }
 
@@ -50,13 +58,11 @@ async function readMenuConfig(filePath: string): Promise<MenuConfig[]> {
 
         // 验证是否为数组
         if (!Array.isArray(content)) {
-            Logger.warn(`菜单配置文件格式错误（非数组）: ${filePath}，使用空数组`);
             return [];
         }
 
         return content;
     } catch (error: any) {
-        Logger.warn(`读取菜单配置失败: ${filePath}，使用空数组`, error.message);
         return [];
     }
 }
@@ -176,7 +182,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                 });
                 parentId = existingParent.id;
                 stats.updated++;
-                Logger.debug(`  └ 更新父级菜单: ${menu.name} (ID: ${parentId}, Path: ${menu.path})`);
             } else {
                 parentId = await helper.insData({
                     table: 'core_menu',
@@ -190,7 +195,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                     }
                 });
                 stats.created++;
-                Logger.debug(`  └ 新增父级菜单: ${menu.name} (ID: ${parentId}, Path: ${menu.path})`);
             }
 
             // 2. 同步子级菜单（自动追加父级路径前缀）
@@ -217,9 +221,8 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                             }
                         });
                         stats.updated++;
-                        Logger.debug(`    └ 更新子级菜单: ${child.name} (ID: ${existingChild.id}, PID: ${parentId}, Path: ${childFullPath})`);
                     } else {
-                        const childId = await helper.insData({
+                        await helper.insData({
                             table: 'core_menu',
                             data: {
                                 pid: parentId,
@@ -231,7 +234,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
                             }
                         });
                         stats.created++;
-                        Logger.debug(`    └ 新增子级菜单: ${child.name} (ID: ${childId}, PID: ${parentId}, Path: ${childFullPath})`);
                     }
                 }
             }
@@ -248,8 +250,6 @@ async function syncMenus(helper: any, menus: MenuConfig[]): Promise<{ created: n
  * 删除配置中不存在的菜单（强制删除）
  */
 async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Promise<number> {
-    Logger.debug(`\n=== 删除配置中不存在的记录 ===`);
-
     const allRecords = await helper.getAll({
         table: 'core_menu',
         fields: ['id', 'path', 'name'],
@@ -264,60 +264,31 @@ async function deleteObsoleteRecords(helper: any, configPaths: Set<string>): Pro
                 where: { id: record.id }
             });
             deletedCount++;
-            Logger.debug(`  └ 删除记录: ${record.name} (ID: ${record.id}, path: ${record.path})`);
         }
     }
 
-    if (deletedCount === 0) {
-        Logger.debug('  ✅ 无需删除的记录');
-    }
-
     return deletedCount;
 }
 
 /**
  * SyncMenu 命令主函数
  */
-export async function syncMenuCommand(options: SyncMenuOptions = {}) {
+export async function syncMenuCommand(options: SyncMenuOptions = {}): Promise<SyncMenuStats> {
     try {
         if (options.plan) {
             Logger.info('[计划] 同步菜单配置到数据库（plan 模式不执行）');
-            Logger.info('[计划] 1. 读取 core/config/menu.json 和项目根目录 menu.json');
-            Logger.info('[计划] 2. 合并菜单配置（core 优先覆盖项目）');
-            Logger.info('[计划] 3. 子级菜单自动追加父级路径前缀');
-            Logger.info('[计划] 4. 根据 path 检查菜单是否存在');
-            Logger.info('[计划] 5. 存在则更新，不存在则新增');
-            Logger.info('[计划] 6. 强制删除配置中不存在的菜单');
-            Logger.info('[计划] 7. 显示菜单结构预览');
-            return;
+            return { totalMenus: 0, parentMenus: 0, childMenus: 0, created: 0, updated: 0, deleted: 0 };
         }
 
-        Logger.info('开始同步菜单配置到数据库...\n');
-
         // 1. 读取两个配置文件
-        Logger.debug('=== 步骤 1: 读取菜单配置文件 ===');
         const projectMenuPath = join(projectDir, 'menu.json');
         const coreMenuPath = join(coreDir, 'menu.json');
 
-        Logger.info(`  项目路径: ${projectMenuPath}`);
-        Logger.info(`  core 路径: ${coreMenuPath}`);
-
         const projectMenus = await readMenuConfig(projectMenuPath);
         const coreMenus = await readMenuConfig(coreMenuPath);
 
-        Logger.info(`✅ 项目配置: ${projectMenus.length} 个父级菜单`);
-        Logger.info(`✅ core 配置: ${coreMenus.length} 个父级菜单`);
-
         // 2. 合并菜单配置
-        Logger.info('\n=== 步骤 2: 合并菜单配置（core 优先覆盖项目） ===');
         const mergedMenus = mergeMenuConfigs(projectMenus, coreMenus);
-        Logger.info(`✅ 合并后共有 ${mergedMenus.length} 个父级菜单`);
-
-        // 打印合并后的菜单结构
-        for (const menu of mergedMenus) {
-            const childCount = menu.children?.length || 0;
-            Logger.debug(`  └ ${menu.name} (${menu.path}) - ${childCount} 个子菜单`);
-        }
 
         // 连接数据库（SQL + Redis）
         await Database.connect();
@@ -325,7 +296,6 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
         const helper = Database.getDbHelper();
 
         // 3. 检查表是否存在
-        Logger.debug('\n=== 步骤 3: 检查数据表 ===');
         const exists = await helper.tableExists('core_menu');
 
         if (!exists) {
@@ -333,47 +303,23 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
             process.exit(1);
         }
 
-        Logger.debug(`✅ 表 core_menu 存在`);
-
         // 4. 收集配置文件中所有菜单的 path
-        Logger.debug('\n=== 步骤 4: 收集配置菜单路径 ===');
         const configPaths = collectPaths(mergedMenus);
-        Logger.debug(`✅ 配置文件中共有 ${configPaths.size} 个菜单路径`);
 
         // 5. 同步菜单
-        Logger.debug('\n=== 步骤 5: 同步菜单数据（新增/更新） ===');
         const stats = await syncMenus(helper, mergedMenus);
 
         // 6. 删除文件中不存在的菜单（强制删除）
         const deletedCount = await deleteObsoleteRecords(helper, configPaths);
 
-        // 7. 构建树形结构预览
-        Logger.debug('\n=== 步骤 7: 菜单结构预览 ===');
+        // 7. 获取最终菜单数据
         const allMenus = await helper.getAll({
             table: 'core_menu',
             fields: ['id', 'pid', 'name', 'path', 'type'],
             orderBy: ['pid#ASC', 'sort#ASC', 'id#ASC']
         });
 
-        const parentMenus = allMenus.filter((m: any) => m.pid === 0);
-        for (const parent of parentMenus) {
-            const children = allMenus.filter((m: any) => m.pid === parent.id);
-            Logger.debug(`  └ ${parent.name} (${parent.path})`);
-            for (const child of children) {
-                Logger.debug(`    └ ${child.name} (${child.path})`);
-            }
-        }
-
-        // 8. 输出统计信息
-        Logger.info(`\n=== 菜单同步完成 ===`);
-        Logger.info(`新增菜单: ${stats.created} 个`);
-        Logger.info(`更新菜单: ${stats.updated} 个`);
-        Logger.info(`删除菜单: ${deletedCount} 个`);
-        Logger.info(`当前父级菜单: ${allMenus.filter((m: any) => m.pid === 0).length} 个`);
-        Logger.info(`当前子级菜单: ${allMenus.filter((m: any) => m.pid !== 0).length} 个`);
-
-        // 9. 缓存菜单数据到 Redis
-        Logger.info('\n=== 步骤 8: 缓存菜单数据到 Redis ===');
+        // 8. 缓存菜单数据到 Redis
         try {
             const menus = await helper.getAll({
                 table: 'core_menu',
@@ -381,16 +327,19 @@ export async function syncMenuCommand(options: SyncMenuOptions = {}) {
                 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)`);
-            }
+            await RedisHelper.setObject('menus:all', menus);
         } catch (error: any) {
-            Logger.error('⚠️ 菜单缓存异常:', error);
+            // 忽略缓存错误
         }
+
+        return {
+            totalMenus: allMenus.length,
+            parentMenus: allMenus.filter((m: any) => m.pid === 0).length,
+            childMenus: allMenus.filter((m: any) => m.pid !== 0).length,
+            created: stats.created,
+            updated: stats.updated,
+            deleted: deletedCount
+        };
     } catch (error: any) {
         Logger.error('菜单同步失败:', error);
         process.exit(1);

package/lib/database.ts

@@ -87,8 +87,6 @@ export class Database {
 
             const version = await Promise.race([healthCheckPromise, timeoutPromise]);
 
-            Logger.info(`数据库连接成功，version: ${version}`);
-
             this.sqlClient = sql;
             return sql;
         } catch (error: any) {
@@ -110,7 +108,6 @@ export class Database {
         if (this.sqlClient) {
             try {
                 await this.sqlClient.close();
-                Logger.info('SQL 连接已关闭');
             } catch (error: any) {
                 Logger.warn('关闭 SQL 连接时出错:', error.message);
             }
@@ -186,7 +183,6 @@ export class Database {
             });
 
             await redis.ping();
-            Logger.info('Redis 连接成功');
 
             this.redisClient = redis;
             return redis;
@@ -203,7 +199,6 @@ export class Database {
         if (this.redisClient) {
             try {
                 this.redisClient.close();
-                Logger.info('Redis 连接已关闭');
             } catch (error: any) {
                 Logger.warn('关闭 Redis 连接时出错:', error);
             }
@@ -233,16 +228,12 @@ export class Database {
     static async connect(options?: { sql?: SqlClientOptions; redis?: boolean }): Promise<void> {
         try {
             if (options?.sql !== false) {
-                Logger.info('正在初始化 SQL 连接...');
                 await this.connectSql(options?.sql);
             }
 
             if (options?.redis !== false) {
-                Logger.info('正在初始化 Redis 连接...');
                 await this.connectRedis();
             }
-
-            Logger.info('数据库连接初始化完成');
         } catch (error: any) {
             Logger.error('数据库初始化失败', error);
             await this.disconnect();

package/lib/logger.ts

@@ -217,10 +217,12 @@ export class Logger {
      * 用于命令开始时提示用户当前环境
      */
     static printEnv(): void {
-        const env = process.env.NODE_ENV || 'development';
-        const envColor = env === 'production' ? chalk.red : env === 'test' ? chalk.yellow : chalk.green;
-        console.log(chalk.gray('────────────────────────────────────────'));
-        console.log(chalk.bold('运行环境: ') + envColor.bold(env.toUpperCase()));
-        console.log(chalk.gray('────────────────────────────────────────'));
+        console.log('========================================');
+        console.log('开始执行完整同步流程');
+        console.log(`当前环境: ${process.env.NODE_ENV || 'development'}`);
+        console.log(`项目名称: ${Env.APP_NAME}`);
+        console.log(`数据库地址: ${Env.DB_HOST}`);
+        console.log(`数据库名称: ${Env.DB_NAME}`);
+        console.log('========================================\n');
     }
 }