env-plugin 0.5.6

package/dist/service/ProxyAutoStarterService.js

@@ -0,0 +1,62 @@
+import { AppError } from "../utils/errors.js";
+import { logger } from "../utils/logger.js";
+/**
+ * 代理自动启动器
+ * 负责在应用启动时检查并启动数据库中状态为运行的代理
+ */
+export class ProxyAutoStarter {
+    constructor(envRepo, proxyService, routeRuleRepo) {
+        this.envRepo = envRepo;
+        this.proxyService = proxyService;
+        this.routeRuleRepo = routeRuleRepo;
+        this.start();
+    }
+    /**
+     * 应用启动时执行的代理检查和启动逻辑
+     */
+    async start() {
+        try {
+            logger.info("开始检查需要自动启动的代理...");
+            // 查询数据库中状态为"运行中"的代理
+            const runningProxies = this.envRepo.findAllByStatus("running");
+            if (runningProxies.length === 0) {
+                logger.info("没有需要自动启动的代理");
+                return;
+            }
+            logger.info(`发现${runningProxies.length}个状态为运行的代理，准备启动...`);
+            // 逐个启动代理，记录成功和失败的数量
+            let successCount = 0;
+            let failCount = 0;
+            // 使用for循环而非forEach以支持异步等待
+            for (const proxy of runningProxies) {
+                try {
+                    logger.info(`正在启动代理 [${proxy.name}] (ID: ${proxy.id})`);
+                    // 检查代理是否已经在运行（避免重复启动）
+                    // await this.proxyService.handleStartServer({
+                    //   id: proxy.id,
+                    // });
+                    // if (isAlreadyRunning) {
+                    //   console.warn(`代理 [${proxy.name}] 已在运行，跳过启动`);
+                    //   successCount++;
+                    //   continue;
+                    // }
+                    // 启动代理
+                    await this.proxyService.handleStartServer(proxy);
+                    logger.info(`代理 [${proxy.name}] 启动成功`);
+                    successCount++;
+                }
+                catch (error) {
+                    logger.error(error, `代理 [${proxy.name}] (ID: ${proxy.id}) 启动失败:`);
+                    failCount++;
+                }
+            }
+            // 输出启动结果统计
+            logger.info(`代理自动启动完成 - 成功: ${successCount}, 失败: ${failCount}, 总计: ${runningProxies.length}`);
+        }
+        catch (error) {
+            logger.error(error, "代理自动启动流程失败:");
+            // 根据实际需求决定是否抛出错误终止应用，或仅记录错误
+            throw new AppError("代理自动启动流程执行失败");
+        }
+    }
+}

package/dist/service/RouteRuleService.js

@@ -0,0 +1,131 @@
+import { v4 as uuidv4 } from "uuid";
+/**
+ * 路由规则服务类
+ * 负责处理与路由规则相关的核心业务逻辑，包括路由规则的增删改查等操作
+ * 依赖路由规则仓库(RouteRuleRepo)和环境仓库(EnvRepo)实现数据持久化和关联操作
+ */
+class RouteRuleService {
+    /**
+     * 构造函数 - 通过依赖注入初始化仓库实例
+     * @param routeRuleRepo - 路由规则仓库实例，用于路由规则数据的持久化操作
+     * @param envRepo - 环境仓库实例，用于获取环境信息
+     */
+    constructor(routeRuleRepo, envRepo) {
+        this.routeRuleRepo = routeRuleRepo;
+        this.envRepo = envRepo;
+    }
+    /**
+     * 获取指定环境的所有路由规则
+     * @param envId - 环境ID
+     * @returns 该环境的所有路由规则数组（实时关联环境名称）
+     */
+    handleGetByEnvId(envId) {
+        const rules = this.routeRuleRepo.getByEnvId(envId);
+        // 实时关联环境名称
+        return rules.map((rule) => {
+            const targetEnv = rule.targetEnvId
+                ? this.envRepo.findOneById(rule.targetEnvId)
+                : null;
+            return {
+                ...rule,
+                targetEnvName: targetEnv
+                    ? `${targetEnv.name}${targetEnv.apiBaseUrl}` || targetEnv.apiBaseUrl
+                    : "",
+            };
+        });
+    }
+    /**
+     * 添加新路由规则
+     * 1. 校验输入参数合法性 2. 检查目标环境是否存在 3. 生成唯一ID 4. 保存
+     * @param routeRuleItem - 待添加的路由规则信息（不含ID）
+     * @returns 新创建的路由规则
+     * @throws {Error} 当输入参数不合法或目标环境不存在时抛出
+     */
+    handleAdd(routeRuleItem) {
+        const { envId, pathPrefix, targetEnvId, injectScript } = routeRuleItem;
+        // 如果目标环境有值，检查目标环境是否存在
+        if (targetEnvId) {
+            const targetEnv = this.envRepo.findOneById(targetEnvId);
+            if (!targetEnv) {
+                throw new Error(`添加失败，目标环境【${targetEnvId}】不存在`);
+            }
+        }
+        else if (!injectScript) {
+            // 未开启注入脚本且目标环境为空时报错
+            throw new Error("添加失败，目标环境不能为空");
+        }
+        // 检查是否已存在相同路径前缀的规则（同一环境下）
+        if (this.routeRuleRepo.existsByEnvIdAndPathPrefix(envId, pathPrefix)) {
+            throw new Error(`添加失败，该环境下已存在路径前缀【${pathPrefix}】的规则`);
+        }
+        // 生成唯一ID并组装完整路由规则信息
+        const now = new Date().toISOString();
+        const newRouteRule = {
+            ...routeRuleItem,
+            id: uuidv4(),
+            createdAt: now,
+            updatedAt: now,
+        };
+        // 保存路由规则
+        this.routeRuleRepo.create(newRouteRule);
+        return newRouteRule;
+    }
+    /**
+     * 更新路由规则
+     * 1. 校验输入参数 2. 检查规则是否存在 3. 检查目标环境是否存在 4. 执行更新
+     * @param routeRuleItem - 包含待更新路由规则ID及字段的对象
+     * @returns 更新后的路由规则
+     * @throws {Error} 当输入参数不合法或规则/目标环境不存在时抛出
+     */
+    handleUpdate(routeRuleItem) {
+        const { id, targetEnvId } = routeRuleItem;
+        // 检查路由规则是否存在
+        const existingRule = this.routeRuleRepo.findOneById(id);
+        if (!existingRule) {
+            throw new Error(`更新失败，路由规则【${id}】不存在`);
+        }
+        // 判断是否需要清空目标环境
+        const shouldClearTarget = targetEnvId === "" || targetEnvId === undefined;
+        if (shouldClearTarget) {
+            // 清空目标环境
+            routeRuleItem.targetEnvId = "";
+        }
+        else if (targetEnvId !== existingRule.targetEnvId) {
+            // 更新了目标环境，检查目标环境是否存在
+            const targetEnv = this.envRepo.findOneById(targetEnvId);
+            if (!targetEnv) {
+                throw new Error(`更新失败，目标环境【${targetEnvId}】不存在`);
+            }
+        }
+        // 如果更新了路径前缀，检查是否与其他规则冲突
+        if (routeRuleItem.pathPrefix &&
+            routeRuleItem.pathPrefix !== existingRule.pathPrefix) {
+            if (this.routeRuleRepo.existsByEnvIdAndPathPrefix(existingRule.envId, routeRuleItem.pathPrefix)) {
+                throw new Error(`更新失败，该环境下已存在路径前缀【${routeRuleItem.pathPrefix}】的规则`);
+            }
+        }
+        // 添加更新时间
+        routeRuleItem.updatedAt = new Date().toISOString();
+        // 执行更新
+        this.routeRuleRepo.update(routeRuleItem);
+        // 返回更新后的规则
+        return this.routeRuleRepo.findOneById(id);
+    }
+    /**
+     * 删除指定路由规则
+     * 1. 校验输入参数 2. 检查规则是否存在 3. 执行删除操作
+     * @param routeRuleItem - 包含待删除路由规则ID的对象
+     * @throws {Error} 当输入参数不合法或规则不存在时抛出
+     */
+    handleDelete(routeRuleItem) {
+        const { id } = routeRuleItem;
+        // 检查路由规则是否存在
+        const existingRule = this.routeRuleRepo.findOneById(id);
+        if (!existingRule) {
+            throw new Error(`删除失败，路由规则【${id}】不存在`);
+        }
+        // 执行删除
+        this.routeRuleRepo.delete(routeRuleItem);
+    }
+}
+export { RouteRuleService };

package/dist/types/index.js

@@ -0,0 +1,5 @@
+export * from "./shared/EnvItem.js";
+export * from "./shared/DevServerItem.js";
+export * from "./shared/EnvmConfig.js";
+export * from "./shared/RouteRule.js";
+export * from "./shared/Password.js";

package/dist/types/shared/BaseRes.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+/**
+ * 基础响应结构的Zod校验规则
+ * 用于统一API返回格式，同时支持前后端类型共享
+ */
+export const BaseResponseSchema = z.object({
+    /**
+     * 状态码
+     * - 200表示成功
+     * - 非200表示异常
+     */
+    code: z.number(),
+    /**
+     * 响应消息
+     * - 成功时为"success"或相关提示
+     * - 失败时为错误描述
+     */
+    message: z.string(),
+    /**
+     * 响应数据
+     * - 可选字段，根据接口需求动态变化
+     * - 类型由泛型参数指定
+     */
+    data: z.unknown().optional(),
+});
+/**
+ * 创建带具体数据类型的响应Schema
+ * 用于后端校验特定接口的响应格式
+ * @param dataSchema 具体数据字段的Zod校验规则
+ * @returns 包含具体数据类型的完整响应Schema
+ */
+export const createResponseSchema = (dataSchema) => {
+    return BaseResponseSchema.extend({
+        data: dataSchema.optional(),
+    });
+};

package/dist/types/shared/DevServerItem.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+/**
+ * 开发服务器主键Schema
+ * 用于标识开发服务器的唯一ID
+ */
+export const DevServerPrimarySchema = z.object({
+    id: z.string().describe("主键"),
+});
+/**
+ * 开发服务器基础信息Schema
+ * 包含开发服务器的基本配置信息
+ */
+export const BaseDevServerSchema = z.object({
+    /**
+     * 开发服务器的名称
+     */
+    name: z.string().describe("开发服务器名称"),
+    /**
+     * 开发服务器的描述
+     */
+    description: z.string().optional().default("").describe("开发服务器描述"),
+    /**
+     * 开发服务器的IP地址或URL
+     */
+    devServerUrl: z.string().describe("开发服务器地址"),
+});
+/**
+ * 完整开发服务器模型Schema
+ * 合并了主键和基础信息，用于创建完整的开发服务器模型
+ */
+export const DevServerModelSchema = DevServerPrimarySchema.extend(BaseDevServerSchema.shape);
+/**
+ * 新增开发服务器Schema
+ * 用于创建新开发服务器时的参数验证，不需要提供id（由系统生成）
+ */
+export const DevServerCreateSchema = BaseDevServerSchema;
+/**
+ * 删除 开发服务器Schema
+ * 用于删除开发服务器时的参数验证，只需要提供开发服务器id
+ */
+export const DevServerDeleteSchema = DevServerPrimarySchema;
+/**
+ * 修改开发服务器Schema
+ * 用于更新开发服务器信息时的参数验证，id为必填项，其他字段可选
+ */
+export const DevServerUpdateSchema = DevServerPrimarySchema.extend(BaseDevServerSchema.partial().shape);
+/**
+ * 查询开发服务器Schema
+ * 用于查询开发服务器信息时的参数验证，只需要提供开发服务器id
+ */
+export const DevServerQuerySchema = DevServerPrimarySchema;

package/dist/types/shared/EnvItem.js

@@ -0,0 +1,57 @@
+import { z } from "zod";
+/**
+ * 环境主键Schema
+ * 用于标识环境的唯一ID
+ */
+export const EnvPrimarySchema = z.object({
+    id: z.string().describe("主键"),
+});
+/**
+ * 环境基础信息Schema
+ * 包含环境的基本配置信息
+ */
+export const EnvItemBaseSchema = z.object({
+    apiBaseUrl: z.string().describe("API服务器地址"),
+    port: z
+        .number()
+        .int("端口号必须是整数")
+        .min(1, "端口号不能小于1")
+        .max(65535, "端口号不能大于65535")
+        .describe("环境绑定端口（必填）"),
+    name: z.string().describe("环境名称").optional(),
+    description: z.string().optional().describe("环境描述"),
+    devServerId: z
+        .string()
+        .min(1, "开发服务器ID不能为空")
+        .optional()
+        .describe("环境绑定的开发服务器ID"),
+    homePage: z.string().optional().describe("环境首页"),
+    status: z.enum(["running", "stopped"]).optional(),
+});
+/**
+ * 完整环境模型Schema
+ * 合并了主键和基础信息，用于创建完整的环境模型
+ */
+export const EnvModelSchema = EnvPrimarySchema.extend(EnvItemBaseSchema.shape);
+/**
+ * 新增环境Schema
+ * 用于创建新环境时的参数验证，不需要提供id（由系统生成）
+ */
+export const EnvCreateSchema = EnvItemBaseSchema.omit({
+    status: true, // 新增时状态由系统自动设置
+});
+/**
+ * 删除环境Schema
+ * 用于删除环境时的参数验证，只需要提供环境id
+ */
+export const EnvDeleteSchema = EnvPrimarySchema;
+/**
+ * 修改环境Schema
+ * 用于更新环境信息时的参数验证，id为必填项，其他字段可选
+ */
+export const EnvUpdateSchema = EnvPrimarySchema.extend(EnvItemBaseSchema.partial().shape);
+/**
+ * 查询环境Schema
+ * 用于查询环境信息时的参数验证，只需要提供环境id
+ */
+export const EnvQuerySchema = EnvPrimarySchema;

package/dist/types/shared/EnvmConfig.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+// 2. 定义环境变量模式
+export const EnvmConfigSchema = z.object({
+    port: z.coerce
+        .number()
+        .min(3000, { message: "端口必须大于等于3000" })
+        .max(65535, { message: "端口必须小于等于65535" })
+        .default(3099), // 自动转换类型
+    apiPrefix: z.string().default("/dev-manage-api"),
+    cookieSuffix: z.string().default("envm"), // 新增 cookie 后缀配置
+    logLevel: z.string().default("info"),
+    injectScriptDir: z
+        .string()
+        .default(".envminject")
+        .optional()
+        .describe("注入脚本的文件夹路径"),
+});

package/dist/types/shared/ListRes.js

@@ -0,0 +1 @@
+export {};

package/dist/types/shared/Password.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+/**
+ * 密码主键Schema
+ */
+export const PasswordPrimarySchema = z.object({
+    id: z.string().describe("主键"),
+});
+/**
+ * 密码基础信息Schema
+ */
+export const PasswordBaseSchema = z.object({
+    envId: z.string().describe("关联的环境ID"),
+    name: z
+        .string()
+        .min(1, "名称不能为空")
+        .describe("密码名称（如：数据库、API密钥等）"),
+    username: z
+        .string()
+        .min(1, "用户名不能为空")
+        .describe("用户名"),
+    password: z
+        .string()
+        .min(1, "密码不能为空")
+        .describe("密码"),
+    description: z.string().optional().describe("描述"),
+    isDefault: z.boolean().optional().default(false).describe("是否为默认密码"),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+});
+/**
+ * 完整密码模型Schema
+ */
+export const PasswordModelSchema = PasswordPrimarySchema.extend(PasswordBaseSchema.shape);
+/**
+ * 新增密码Schema
+ */
+export const PasswordCreateSchema = PasswordBaseSchema.omit({
+    createdAt: true,
+    updatedAt: true,
+});
+/**
+ * 删除密码Schema
+ */
+export const PasswordDeleteSchema = PasswordPrimarySchema;
+/**
+ * 修改密码Schema
+ */
+export const PasswordUpdateSchema = PasswordPrimarySchema.extend(PasswordBaseSchema.partial().shape);

package/dist/types/shared/RouteRule.js

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/**
+ * 路由规则主键Schema
+ */
+export const RouteRulePrimarySchema = z.object({
+    id: z.string().describe("主键"),
+});
+/**
+ * 路由规则基础信息Schema
+ */
+export const RouteRuleBaseSchema = z.object({
+    envId: z.string().describe("关联的环境ID"),
+    pathPrefix: z
+        .string()
+        .min(1, "路径前缀不能为空")
+        .describe("请求路径前缀，如 /api/user"),
+    targetEnvId: z
+        .string()
+        .optional()
+        .describe("目标环境ID（转发到此环境）"),
+    description: z.string().optional().describe("描述"),
+    enabled: z.boolean().optional().default(true).describe("是否启用"),
+    injectScript: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("是否注入Script脚本"),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+});
+/**
+ * 完整路由规则模型Schema
+ */
+export const RouteRuleModelSchema = RouteRulePrimarySchema.extend(RouteRuleBaseSchema.shape);
+/**
+ * 新增路由规则Schema
+ */
+export const RouteRuleCreateSchema = RouteRuleBaseSchema.omit({
+    createdAt: true,
+    updatedAt: true,
+});
+/**
+ * 删除路由规则Schema
+ */
+export const RouteRuleDeleteSchema = RouteRulePrimarySchema;
+/**
+ * 修改路由规则Schema
+ */
+export const RouteRuleUpdateSchema = RouteRulePrimarySchema.extend(RouteRuleBaseSchema.partial().shape);

package/dist/utils/ResolveConfig.js

@@ -0,0 +1,79 @@
+// config.ts
+import { z } from "zod";
+import dotenv from "dotenv";
+import { EnvmConfigSchema } from "../types/index.js";
+import path from "path";
+import fs from "fs";
+// 缓存已解析的配置（避免重复加载，实现“单例”效果）
+let cachedConfig = null;
+/**
+ * 从 package.json 读取 envm 配置（支持自定义路径）
+ */
+const getPackageJsonConfig = () => {
+    const defaultPath = path.resolve(process.cwd(), "package.json");
+    const targetPath = defaultPath;
+    try {
+        const content = fs.readFileSync(targetPath, "utf8");
+        const pkg = JSON.parse(content);
+        return pkg.envm || {};
+    }
+    catch {
+        console.warn(`⚠️ 无法读取 package.json（路径：${targetPath}）中的 envm 配置，将忽略这部分配置:`);
+        return {};
+    }
+};
+/**
+ * 加载并解析配置（核心函数）
+ * @param options 动态配置参数（优先级最高）
+ * @returns 验证后的配置对象
+ */
+export const loadConfig = (overrideConfig) => {
+    // 1. 单例保护：已加载过则直接返回缓存，避免重复IO和解析
+    if (cachedConfig)
+        return cachedConfig;
+    try {
+        // 2. 加载 .env 文件（支持自定义路径）
+        const dotenvResult = dotenv.config();
+        if (dotenvResult.error) {
+            console.warn("⚠️ 未找到 .env 文件，忽略...");
+        }
+        const { envm_port: port, envm_apiPrefix: apiPrefix, envm_cookieSuffix: cookieSuffix, envm_logLevel: logLevel, envm_injectScriptDir: injectScriptDir, } = process.env;
+        // 3. 读取 package.json 配置（支持自定义路径）
+        const packageJsonConfig = getPackageJsonConfig();
+        // 4. 合并配置：环境变量优先级 > package.json 配置
+        // 3. 合并配置：优先级从低到高
+        const mergedConfig = {
+            ...packageJsonConfig, // 最低优先级
+            port, // 中间优先级
+            apiPrefix,
+            cookieSuffix,
+            logLevel,
+            injectScriptDir,
+            ...overrideConfig, // 最高优先级（外部传入的配置）
+        };
+        // 5. Zod 验证
+        const parsedConfig = EnvmConfigSchema.parse(mergedConfig);
+        // 6. 缓存配置并返回
+        cachedConfig = parsedConfig;
+        console.log("✅ 配置加载与验证成功", cachedConfig);
+        return parsedConfig;
+    }
+    catch (error) {
+        // 7. 精细化错误处理
+        if (error instanceof z.ZodError) {
+            throw new Error(`配置字段错误：${error.issues
+                .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+                .join("; ")}`);
+        }
+        throw new Error(`配置加载异常：${error.message}`);
+    }
+};
+/**
+ * 获取已加载的配置（需在 loadConfig() 后调用）
+ * @returns 缓存的配置对象
+ */
+export const getConfig = () => {
+    if (!cachedConfig)
+        throw new Error("配置未加载，请先调用 loadConfig()");
+    return cachedConfig;
+};

package/dist/utils/errors.js

@@ -0,0 +1,8 @@
+// src/utils/errors.ts
+export class AppError extends Error {
+    constructor(message, code = 500, status = 500) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/utils/logger.js

@@ -0,0 +1,93 @@
+// src/utils/logger.ts
+import pino from "pino";
+import { execSync } from "child_process";
+import os from "os";
+/**
+ * 自动将终端编码切换为 UTF-8（跨平台）
+ */
+function setTerminalEncodingToUtf8() {
+    const platform = os.platform();
+    try {
+        if (platform === "win32") {
+            // Windows 系统：切换代码页为 UTF-8（65001）
+            // execSync 执行 cmd 命令，stdio: 'ignore' 避免命令输出干扰日志
+            execSync("chcp 65001", { stdio: "ignore" });
+            console.log("Windows 终端已切换为 UTF-8 编码（代码页 65001）");
+        }
+        else if (platform === "linux" || platform === "darwin") {
+            // Linux/macOS 系统：设置 LC_ALL 为 UTF-8（临时生效）
+            // 注意：类 Unix 系统编码通常由 locale 控制，这里仅临时覆盖
+            process.env.LC_ALL = "en_US.UTF-8";
+            console.log("类 Unix 终端已设置为 UTF-8 编码");
+        }
+    }
+    catch (error) {
+        console.warn("切换终端编码失败，可能导致中文乱码：", error);
+    }
+}
+// 在日志初始化前调用，确保编码已切换
+setTerminalEncodingToUtf8();
+let rootLogger = null;
+/**
+ * 创建根日志实例（Node.js 环境专用）
+ * 优先级：customOptions > 默认配置
+ */
+export const createRootLogger = (logLevel) => {
+    if (rootLogger)
+        return rootLogger;
+    const level = logLevel || "info";
+    // 默认配置：区分开发/生产环境
+    const defaultConfig = {
+        level, // 从配置读取日志级别
+        base: {
+            service: "envm-service", // 服务名（多服务日志区分）
+            // env: options.config.env || "development", // 环境标识（dev/prod/test）
+            pid: process.pid, // Node.js 进程 ID
+        },
+        // 开发环境：格式化输出（pino-pretty）；生产环境：JSON 格式（便于日志收集工具解析）
+        transport: {
+            target: "pino-pretty",
+            options: {
+                colorize: true,
+                encoding: "utf8",
+                translateTime: "yyyy-mm-dd HH:MM:ss",
+                hideObject: level === "info",
+            },
+        },
+        // transport: options.config.env === "development"
+        //   ? { target: "pino-pretty", options: { colorize: true, translateTime: "yyyy-MM-dd HH:mm:ss" } }
+        //   : undefined,
+        timestamp: pino.stdTimeFunctions.isoTime, // ISO 时间格式
+        redact: ["req.headers.authorization", "res.data.token"], // 敏感字段脱敏（生产环境必备）
+    };
+    // 合并默认配置与自定义配置
+    rootLogger = pino({ ...defaultConfig });
+    return rootLogger;
+};
+/**
+ * 初始化模块级日志（单例，全局复用）
+ * 按业务模块分类，避免日志混乱
+ */
+export let logger; // 环境管理模块日志
+export let envLogger; // 环境管理模块日志
+export let devServerLogger; // 开发服务器模块日志
+export let proxyLogger; // 代理模块日志
+/**
+ * Node.js 日志初始化入口（需在 config 加载后调用）
+ */
+export const initLoggers = (logLevel) => {
+    const rootLog = createRootLogger(logLevel);
+    // 为每个模块创建子日志（附加 module 标识，便于筛选）
+    logger = rootLog.child({ module: "envm" });
+    envLogger = rootLog.child({ module: "env" });
+    devServerLogger = rootLog.child({ module: "devServer" });
+    proxyLogger = rootLog.child({ module: "proxy" });
+};
+/**
+ * 获取根日志实例（确保已初始化）
+ */
+export const getRootLogger = () => {
+    if (!rootLogger)
+        throw new Error("日志未初始化，请先调用 initNodeLoggers()");
+    return rootLogger;
+};