befly 3.76.7 → 3.77.1

package/hooks/auth.js

@@ -29,8 +29,14 @@ export default {
             ctx.roleCode = sessionData.roleCode;
             ctx.roleType = sessionData.roleType;
 
+            // 距上次续期不足半衰期时不续，避免每个请求两次 Redis 往返
+            const renewedAt = Number(sessionData.renewedAt || sessionData.loginAt || 0);
+            if (Date.now() - renewedAt < (ttlSeconds * 1000) / 2) {
+                return;
+            }
+
             try {
-                await befly.redis.expire(sessionKey, ttlSeconds);
+                await Promise.all([befly.redis.expire(sessionKey, ttlSeconds), befly.redis.setObject(sessionKey, { ...sessionData, renewedAt: Date.now() }, ttlSeconds)]);
             } catch (error) {
                 Logger.warn("刷新会话有效期失败", { error: error, sessionKey: sessionKey });
             }

package/hooks/permission.js

@@ -1,11 +1,12 @@
 import { HOOK_ORDER } from "../configs/constConfig.js";
-import { isValidPositiveInt } from "../utils/is.js";
+import { isSuperAdminContext, isValidPositiveInt } from "../utils/is.js";
 // 相对导入
 import { ErrorResponse } from "../utils/response.js";
 
 /**
  * 权限检查钩子
  * - 接口无需权限（auth=false）：直接通过
+ * - 超级管理员专属（auth="dev"）：仅管理员表 dev/admin 角色可用，不参与角色授权
  * - auth 为角色类型白名单（string[]，如 ["admin"] / ["user"]）：按 ctx.roleType 校验。
  *   类型与角色解耦：管理员表（beflyAdmin）roleType 固定 "admin"，用户表固定 "user"，
  *   任意角色 code 的管理员共享 "admin" 类型门槛，细粒度授权由下方集合检查（roleCode）负责
@@ -33,6 +34,26 @@ export default {
             return;
         }
 
+        // 3.4 超级管理员专属接口（auth="dev"）：仅管理员表 dev/admin 角色可用，
+        // 为天生权限，不查角色权限集合，也不允许分配给任何角色
+        if (ctx.apiAuth === "dev") {
+            if (isSuperAdminContext(ctx)) {
+                return;
+            }
+            ctx.response = ErrorResponse(
+                ctx,
+                `无权访问 ${ctx.apiName} 接口`,
+                1,
+                null,
+                {
+                    apiName: ctx.apiName,
+                    apiPath: ctx.apiPath
+                },
+                "permission"
+            );
+            return;
+        }
+
         // 3.5 apiAuth 为角色类型白名单时，仅做 ctx.roleType 校验
         if (Array.isArray(ctx.apiAuth) && ctx.apiAuth.includes(ctx.roleType) === false) {
             ctx.response = ErrorResponse(

package/hooks/rateLimit.js

@@ -13,6 +13,27 @@ function getSkipMatchers(config) {
     return matchers;
 }
 
+function getRuleMatchers(config) {
+    if (!Array.isArray(config.rules) || config.rules.length === 0) {
+        return [];
+    }
+    let matchers = matcherCache.get(config.rules);
+    if (!matchers) {
+        // rules: [{ path: "/api/guest/login/*", limit: 10, window: 60 }]，首个匹配生效，未命中用默认值
+        matchers = config.rules.map((rule) => ({ matcher: new Bun.Glob(rule.path), limit: rule.limit, window: rule.window }));
+        matcherCache.set(config.rules, matchers);
+    }
+    return matchers;
+}
+
+function resolveRateRule(config, apiPath) {
+    const hit = getRuleMatchers(config).find((rule) => rule.matcher.match(apiPath));
+    if (hit) {
+        return { limit: hit.limit, window: hit.window };
+    }
+    return { limit: config.defaultLimit, window: config.defaultWindow };
+}
+
 function resolveScope(keyType, ctx) {
     if (keyType === "userId") return isValidPositiveInt(ctx.userId) ? `user:${ctx.userId}` : `ip:${ctx.ip}`;
     if (keyType === "roleCode") return `role:${ctx.roleCode || "guest"}`;
@@ -37,19 +58,29 @@ export default {
         }
 
         const scope = resolveScope(config.key, ctx);
+        const rule = resolveRateRule(config, ctx.apiPath);
         const key = `rate_limit:${ctx.apiPath}:${ctx.method}:${config.key}:${scope}`;
-        const current = await befly.redis.incrWithExpire(key, config.defaultWindow);
-        if (current <= config.defaultLimit) return;
+        let current;
+        try {
+            current = await befly.redis.incrWithExpire(key, rule.window);
+        } catch {
+            // 计数器故障时按 failOpen 配置决定放行或拒绝，不静默失效
+            if (config.failOpen) return;
+            ctx.corsHeaders["Retry-After"] = String(rule.window);
+            ctx.response = ErrorResponse(ctx, "服务繁忙，请稍后再试", 1, null, { reason: "rate_limit_unavailable" }, "rateLimit");
+            return;
+        }
+        if (current <= rule.limit) return;
 
-        ctx.corsHeaders["Retry-After"] = String(config.defaultWindow);
+        ctx.corsHeaders["Retry-After"] = String(rule.window);
         ctx.response = ErrorResponse(
             ctx,
             "请求过于频繁，请稍后再试",
             1,
             null,
             {
-                limit: config.defaultLimit,
-                window: config.defaultWindow,
+                limit: rule.limit,
+                window: rule.window,
                 current: current,
                 apiPath: ctx.apiPath,
                 key: config.key

package/hooks/validator.js

@@ -1,6 +1,6 @@
 import { compile } from "#befly/libs/validator/index.js";
 
-import { getFieldSchema } from "../checks/field.js";
+import { buildApiSchema, getFieldErrors } from "../checks/field.js";
 import { HOOK_ORDER } from "../configs/constConfig.js";
 import { isPlainObject } from "../utils/is.js";
 import { ErrorResponse } from "../utils/response.js";
@@ -17,20 +17,9 @@ function getValidator(fields, required, constraints) {
     const cacheKey = JSON.stringify([required, constraints]);
     let validate = validators.get(cacheKey);
     if (validate) return validate;
-    const requiredSet = new Set(required);
-    validate = compile({
-        paramType: "object",
-        fields: Object.fromEntries(
-            Object.entries(fields).map(([field, definition]) => [
-                field,
-                {
-                    ...getFieldSchema(definition),
-                    optional: !requiredSet.has(field)
-                }
-            ])
-        ),
-        constraints: constraints
-    });
+    // 前提：fields 与 required/constraints 均来自启动期扫描的静态 apiData，
+    // 每个 fields 对象在内层 Map 只会有一个缓存条目，无需淘汰策略
+    validate = compile(buildApiSchema(fields, required, constraints));
     validators.set(cacheKey, validate);
     return validate;
 }
@@ -54,7 +43,7 @@ export default {
             return;
         }
 
-        const fieldErrors = Object.fromEntries(result.issues.map((issue) => [issue.path[0], `${ctx.apiFields[issue.path[0]]?.name || issue.path[0]}${issue.message}`]));
+        const fieldErrors = getFieldErrors(result.issues, ctx.apiFields);
         ctx.response = ErrorResponse(ctx, Object.values(fieldErrors)[0] || "参数验证失败", 1, null, fieldErrors, "validator");
     }
 };

package/index.js

@@ -12,6 +12,7 @@ import beflyMenus from "./configs/beflyMenus.json";
 import { calcPerfTime } from "./utils/calcPerfTime.js";
 import { deepMerge } from "./utils/deepMerge.js";
 import { createError } from "./utils/error.js";
+import { printErrorSummary } from "./utils/prettyError.js";
 import { scanSources } from "./utils/scanSources.js";
 import { getRunMode } from "./utils/util.js";
 
@@ -33,49 +34,56 @@ function prefixMenuPaths(menus, prefix) {
 }
 
 export async function createBefly(config = {}, menus = []) {
-    const mergeStartTime = Bun.nanoseconds();
-    const mergedConfig = deepMerge(beflyConfig, config);
-    const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
+    try {
+        const mergeStartTime = Bun.nanoseconds();
+        const mergedConfig = deepMerge(beflyConfig, config);
+        const mergedMenus = deepMerge(prefixMenuPaths(beflyMenus, "core"), menus);
 
-    Logger.configure({ runtimeEnv: getRunMode(), ...mergedConfig.logger });
-    Logger.info(`启动 合并配置 耗时 ${calcPerfTime(mergeStartTime)}`);
+        await Logger.configure({ runtimeEnv: getRunMode(), ...mergedConfig.logger });
+        Logger.info(`启动 合并配置 耗时 ${calcPerfTime(mergeStartTime)}`);
 
-    let stageStartTime = Bun.nanoseconds();
-    const configErrors = await checkConfig(mergedConfig);
-    Logger.info(`启动 检查配置 耗时 ${calcPerfTime(stageStartTime)}`);
+        let stageStartTime = Bun.nanoseconds();
+        const configErrors = await checkConfig(mergedConfig);
+        Logger.info(`启动 检查配置 耗时 ${calcPerfTime(stageStartTime)}`);
 
-    stageStartTime = Bun.nanoseconds();
-    const { apis, tables, plugins, hooks, corns } = await scanSources({ beflyMode: mergedConfig.mysql.beflyMode });
-    Logger.info(`启动 扫描源码 耗时 ${calcPerfTime(stageStartTime)}`);
+        stageStartTime = Bun.nanoseconds();
+        const { apis, tables, plugins, hooks, corns } = await scanSources({ beflyMode: mergedConfig.mysql.beflyMode });
+        Logger.info(`启动 扫描源码 耗时 ${calcPerfTime(stageStartTime)}`);
 
-    const checks = [
-        ["配置", configErrors],
-        ["接口", await checkApi(apis)],
-        ["表结构", await checkTable(tables)],
-        ["插件", await checkPlugin(plugins)],
-        ["钩子", await checkHook(hooks)],
-        ["定时器", checkCorn(corns)],
-        ["菜单", await checkMenu(mergedMenus)]
-    ];
-    const failedChecks = checks.filter(([, errors]) => errors.length > 0).map(([check, errors]) => ({ check: check, errors: errors }));
+        const checks = [
+            ["配置", configErrors],
+            ["接口", await checkApi(apis)],
+            ["表结构", await checkTable(tables)],
+            ["插件", await checkPlugin(plugins)],
+            ["钩子", await checkHook(hooks)],
+            ["定时器", checkCorn(corns)],
+            ["菜单", await checkMenu(mergedMenus)]
+        ];
+        const failedChecks = checks.filter(([, errors]) => errors.length > 0).map(([check, errors]) => ({ check: check, errors: errors }));
 
-    if (failedChecks.length > 0) {
-        throw createError("检查失败：存在配置/结构问题", {
-            code: "policy",
-            subsystem: "checks",
-            operation: "checkAll",
-            errors: failedChecks
+        if (failedChecks.length > 0) {
+            throw createError("检查失败：存在配置/结构问题", {
+                code: "policy",
+                subsystem: "checks",
+                operation: "checkAll",
+                errors: failedChecks
+            });
+        }
+
+        mergedConfig.runMode = getRunMode();
+        return new Befly({
+            config: mergedConfig,
+            tables: tables,
+            menus: mergedMenus,
+            apis: apis,
+            hooks: hooks,
+            plugins: plugins,
+            corns: corns
         });
+    } catch (error) {
+        printErrorSummary(error, { title: "启动失败" });
+        Logger.error("启动失败", error);
+        await Logger.shutdown();
+        throw error;
     }
-
-    mergedConfig.runMode = getRunMode();
-    return new Befly({
-        config: mergedConfig,
-        tables: tables,
-        menus: mergedMenus,
-        apis: apis,
-        hooks: hooks,
-        plugins: plugins,
-        corns: corns
-    });
 }

package/libs/cacheHelper.js

@@ -7,6 +7,10 @@ import { Logger } from "#befly/libs/logger/index.js";
 import { BEFLY_API_TABLE, BEFLY_MENU_TABLE, BEFLY_ROLE_TABLE } from "../configs/constConfig.js";
 import { createError } from "../utils/error.js";
 import { isNonEmptyString, isNullable, isString } from "../utils/is.js";
+import { memRemember, memSet } from "./memCache.js";
+
+// 角色权限版本号变化频率极低（仅启动全量重建时切换），进程内短缓存可省掉每请求一次 getString 往返
+const ROLE_VERSION_CACHE_TTL_MS = 3000;
 
 /**
  * 缓存助手类
@@ -35,13 +39,10 @@ export class CacheHelper {
 
     async getRoleCacheActiveVersion(kind) {
         const versionKey = this.getRoleCacheVersionKey(kind);
-        const version = await this.redis.getString(versionKey);
-
-        if (!isNonEmptyString(version)) {
-            return "";
-        }
-
-        return version;
+        return await memRemember(`befly:cache:${versionKey}`, ROLE_VERSION_CACHE_TTL_MS, async () => {
+            const version = await this.redis.getString(versionKey);
+            return isNonEmptyString(version) ? version : "";
+        });
     }
 
     async getRoleCacheReadKey(kind, roleCode) {
@@ -82,6 +83,7 @@ export class CacheHelper {
         }
 
         await this.redis.setString(this.getRoleCacheVersionKey(kind), nextVersion);
+        memSet(`befly:cache:${this.getRoleCacheVersionKey(kind)}`, nextVersion, ROLE_VERSION_CACHE_TTL_MS);
 
         if (!oldVersion || oldVersion === nextVersion) {
             return;
@@ -107,18 +109,11 @@ export class CacheHelper {
      */
     async cacheAllItems(kind, table) {
         try {
+            // setObject 失败会直接抛错阻断启动（写操作 fail-fast），无需返回值判断
             const items = await this.mysql.getAll({
                 table: table
             });
-
-            const result = await this.redis.setObject(`${kind}:all`, items.data.lists);
-
-            if (result === null) {
-                Logger.warn(`⚠️ ${kind} 缓存失败`, {
-                    subsystem: "cache",
-                    operation: "cacheAllItems"
-                });
-            }
+            await this.redis.setObject(`${kind}:all`, items.data.lists);
         } catch (error) {
             throw createError(`${kind} 缓存异常`, { cause: error, code: "runtime", subsystem: "cache", operation: "cacheAllItems" });
         }
@@ -178,9 +173,9 @@ export class CacheHelper {
     }
 
     /**
-     * 增量刷新单个角色的某类权限缓存
+     * 增量刷新单个角色的某类权限缓存（写入当前活跃版本 key）
      * - paths 为空数组：仅清理缓存（防止残留）
-     * - paths 非空：使用最小查询，DEL 后 SADD
+     * - paths 非空：DEL 后 SADD
      * @param kind - 权限类别（apis/menus）
      */
     async refreshRoleItems(kind, roleCode, paths) {

package/libs/logger/logger.js

@@ -6,6 +6,10 @@ import { buildSensitiveKeyMatcher, isPlainObject, sanitizeLogRecord } from "./sa
 const builtinSensitiveKeys = ["*password*", "pass", "pwd", "*token*", "access_token", "refresh_token", "accessToken", "refreshToken", "authorization", "cookie", "set-cookie", "*secret*", "apiKey", "api_key", "privateKey", "private_key"];
 const textEncoder = new TextEncoder();
 
+// 单条日志与单次写入批次的字节上限（正常不触发，仅极端兜底）
+const MAX_LINE_LENGTH = 65536;
+const MAX_WRITE_BATCH_BYTES = 65536;
+
 let config;
 let sanitizeOptions;
 let mockInstance = null;
@@ -26,13 +30,20 @@ function formatTime(value, dateOnly = false) {
     const hour = String(date.getHours()).padStart(2, "0");
     const minute = String(date.getMinutes()).padStart(2, "0");
     const second = String(date.getSeconds()).padStart(2, "0");
-    return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+    const millisecond = String(date.getMilliseconds()).padStart(3, "0");
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}.${millisecond}`;
 }
 
 function writeStderr(message) {
     Bun.stderr.write(`[befly-logger] ${message}\n`);
 }
 
+// 次日零点时间戳：日期滚动判断只做一次数值比较，避免每行格式化日期字符串
+function computeNextDayMs() {
+    const now = new Date();
+    return new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).getTime();
+}
+
 class FileSink {
     constructor(prefix, sinkConfig) {
         this.prefix = prefix;
@@ -43,6 +54,11 @@ class FileSink {
         this.size = 0;
         this.pending = Promise.resolve();
         this.disabled = false;
+        this.queue = [];
+        this.flushScheduled = false;
+        this.droppedCount = 0;
+        this.maxQueueLines = normalizeInteger(sinkConfig.maxQueueLines, 10000, 1, 100000);
+        this.nextDayMs = 0;
     }
 
     getPath(date, index) {
@@ -59,6 +75,7 @@ class FileSink {
             this.disabled = true;
             writeStderr(`写入失败 (${this.prefix}): ${error.message || error}`);
         });
+        this.nextDayMs = computeNextDayMs();
     }
 
     close(resetPosition = true) {
@@ -76,17 +93,16 @@ class FileSink {
     }
 
     async prepare(bytes) {
-        const date = formatTime(Date.now(), true);
-        if (this.stream && this.date !== date) await this.close();
+        if (this.stream && Date.now() >= this.nextDayMs) await this.close();
 
         if (!this.stream) {
-            this.date = date;
+            this.date = formatTime(Date.now(), true);
             this.index = 0;
-            let path = this.getPath(date, this.index);
+            let path = this.getPath(this.date, this.index);
             this.size = Bun.file(path).size;
             while (this.prefix !== "dev" && this.size > 0 && this.size + bytes > this.config.maxBytes) {
                 this.index += 1;
-                path = this.getPath(date, this.index);
+                path = this.getPath(this.date, this.index);
                 this.size = Bun.file(path).size;
             }
             this.open(path);
@@ -95,22 +111,60 @@ class FileSink {
         if (this.prefix !== "dev" && this.size > 0 && this.size + bytes > this.config.maxBytes) {
             await this.close(false);
             this.index += 1;
-            this.size = Bun.file(this.getPath(date, this.index)).size;
-            this.open(this.getPath(date, this.index));
+            this.size = Bun.file(this.getPath(this.date, this.index)).size;
+            this.open(this.getPath(this.date, this.index));
         }
     }
 
+    // 写入入口：单次编码、超长截断、入队（有界）、按需调度冲刷
     write(line) {
         if (this.disabled) return;
-        const bytes = textEncoder.encode(line).byteLength;
-        this.pending = this.pending.then(async () => {
-            await this.prepare(bytes);
+        const text = line.length > MAX_LINE_LENGTH ? `${line.slice(0, MAX_LINE_LENGTH)}[截断，原 ${line.length} 字符]\n` : line;
+        const buffer = textEncoder.encode(text);
+        this.queue.push({ buffer: buffer, bytes: buffer.byteLength });
+
+        // 日志风暴/磁盘卡顿时有界丢弃最旧行，恢复后补摘要标记
+        while (this.queue.length > this.maxQueueLines) {
+            this.queue.shift();
+            this.droppedCount += 1;
+        }
+
+        if (this.flushScheduled) return;
+        this.flushScheduled = true;
+        // 链尾 catch 隔离单次写失败：保持 pending 永远 resolved，
+        // 避免未处理 rejection 与后续日志全部静默丢失
+        this.pending = this.pending
+            .then(async () => {
+                await this.drain();
+            })
+            .catch((error) => {
+                writeStderr(`写入失败 (${this.prefix}): ${error?.message || error}`);
+            });
+    }
+
+    // 冲刷队列：积压行合并为批次（单次系统调用），串行保持顺序
+    async drain() {
+        this.flushScheduled = false;
+
+        if (this.droppedCount > 0) {
+            const marker = textEncoder.encode(`{"level":"warn","time":"${formatTime(Date.now())}","pid":${process.pid},"msg":"[日志拥塞，已丢弃 ${this.droppedCount} 行]"}\n`);
+            this.queue.unshift({ buffer: marker, bytes: marker.byteLength });
+            this.droppedCount = 0;
+        }
+
+        while (this.queue.length > 0) {
+            let batch = this.queue.shift();
+            while (this.queue.length > 0 && batch.bytes + this.queue[0].bytes <= MAX_WRITE_BATCH_BYTES) {
+                batch = mergeBatch(batch, this.queue.shift());
+            }
+
+            await this.prepare(batch.bytes);
             if (!this.stream || this.disabled) return;
-            this.size += bytes;
+            this.size += batch.bytes;
             await new Promise((resolveWrite) => {
-                this.stream.write(line, resolveWrite);
+                this.stream.write(batch.buffer, resolveWrite);
             });
-        });
+        }
     }
 
     async flush() {
@@ -123,6 +177,13 @@ class FileSink {
     }
 }
 
+function mergeBatch(left, right) {
+    const merged = new Uint8Array(left.bytes + right.bytes);
+    merged.set(left.buffer, 0);
+    merged.set(right.buffer, left.bytes);
+    return { buffer: merged, bytes: merged.byteLength };
+}
+
 function resetConfig(options = {}) {
     const runtimeEnv = options.runtimeEnv === "development" ? "development" : "production";
     const dir = options.dir ? resolve(options.dir) : resolve(process.cwd(), "logs");
@@ -140,7 +201,10 @@ function resetConfig(options = {}) {
     sanitizeOptions = {
         sanitizeDepth: normalizeInteger(options.sanitizeDepth, 5, 1, 10),
         sanitizeNodes: normalizeInteger(options.sanitizeNodes, 5000, 50, 20000),
-        sanitizeObjectKeys: normalizeInteger(options.sanitizeObjectKeys, 500, 10, 5000),
+        sanitizeObjectKeys: normalizeInteger(options.sanitizeObjectKeys, 50, 5, 500),
+        truncateStringLength: normalizeInteger(options.truncateStringLength, 512, 32, 65536),
+        truncateArrayLength: normalizeInteger(options.truncateArrayLength, 20, 1, 1000),
+        truncatePreviewLength: normalizeInteger(options.truncatePreviewLength, 200, 32, 65536),
         sensitiveKeyMatcher: buildSensitiveKeyMatcher(builtinSensitiveKeys, options.excludeFields)
     };
 }
@@ -154,16 +218,25 @@ function prepareDirectory(clearDevelopmentLog) {
 }
 
 function getSink(level) {
-    prepareDirectory(false);
+    // 目录只在新建 sink 时确保一次，避免每条日志一次 mkdirSync 系统调用
     if (config.runtimeEnv === "development") {
-        if (!appSink) appSink = new FileSink("dev", config);
+        if (!appSink) {
+            prepareDirectory(false);
+            appSink = new FileSink("dev", config);
+        }
         return appSink;
     }
     if (level === "error") {
-        if (!errorSink) errorSink = new FileSink("error", config);
+        if (!errorSink) {
+            prepareDirectory(false);
+            errorSink = new FileSink("error", config);
+        }
         return errorSink;
     }
-    if (!appSink) appSink = new FileSink("app", config);
+    if (!appSink) {
+        prepareDirectory(false);
+        appSink = new FileSink("app", config);
+    }
     return appSink;
 }
 
@@ -176,7 +249,7 @@ function toRecord(input) {
     try {
         return { msg: String(input) };
     } catch {
-        return { msg: "[Unserializable]" };
+        return { msg: "[无法序列化的日志记录]" };
     }
 }
 
@@ -193,7 +266,7 @@ function buildLine(level, record) {
     try {
         return `${JSON.stringify(output)}\n`;
     } catch {
-        return `${JSON.stringify({ level: level, time: output.time, pid: process.pid, msg: "[Unserializable log record]" })}\n`;
+        return `${JSON.stringify({ level: level, time: output.time, pid: process.pid, msg: "[无法序列化的日志记录]" })}\n`;
     }
 }
 
@@ -222,13 +295,14 @@ export const Logger = {
         write("error", isPlainObject(message) ? message : { msg: message, err: error, data: data });
     },
     debug: createMethod("debug"),
-    configure: function (options = {}) {
+    configure: async function (options = {}) {
         const sinks = [appSink, errorSink].filter(Boolean);
         appSink = null;
         errorSink = null;
-        for (const sink of sinks) sink.shutdown().catch((error) => writeStderr(`关闭失败: ${error.message || error}`));
+        // 配置即时生效（同步重置），旧 sink 关闭异步等待，避免新旧并发期间的配置错位
         resetConfig(options);
         prepareDirectory(config.clearDevelopmentLog);
+        await Promise.allSettled(sinks.map((sink) => sink.shutdown()));
     },
     setMock: function (mock) {
         mockInstance = mock;
@@ -241,6 +315,11 @@ export const Logger = {
         const sinks = [appSink, errorSink].filter(Boolean);
         appSink = null;
         errorSink = null;
-        await Promise.all(sinks.map((sink) => sink.shutdown()));
+        const results = await Promise.allSettled(sinks.map((sink) => sink.shutdown()));
+        for (const result of results) {
+            if (result.status === "rejected") writeStderr(`关闭失败: ${result.reason?.message || result.reason}`);
+        }
     }
 };
+
+export { FileSink };