@maiyunnet/kebab 9.15.6 → 9.16.1

package/index.d.ts

@@ -5,7 +5,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export declare const VER = "9.15.6";
+export declare const VER = "9.16.1";
 /** --- 框架根目录，以 / 结尾  --- */
 export declare const ROOT_PATH: string;
 /** --- 框架的 LIB，以 / 结尾 --- */

package/index.js

@@ -6,7 +6,7 @@
  * --- 本文件用来定义每个目录实体地址的常量 ---
  */
 /** --- 当前系统版本号 --- */
-export const VER = '9.15.6';
+export const VER = '9.16.1';
 // --- 服务端用的路径 ---
 const imu = decodeURIComponent(import.meta.url).replace('file://', '').replace(/^\/(\w:)/, '$1');
 /** --- /xxx/xxx --- */

package/lib/core.d.ts

@@ -352,12 +352,31 @@ export declare function debug(message?: any, ...optionalParams: any[]): void;
  */
 export declare function display(message?: any, ...optionalParams: any[]): void;
 /**
- * --- 让 res 发送头部（前提是头部没有被发送才能调用本方法 ---
+ * --- 提交 HTTP 响应状态和头部，兼容 HTTP/1.1 与 HTTP/2 ---
+ *
+ * `setHeader()` 只暂存或修改单个头部，不会发送响应头，也不能提交状态码；在响应头提交前可反复调用。
+ * 本方法会立即提交状态码和此前设置的全部头部，必须在所有 `setHeader()` 调用之后、首次
+ * `write()`、`end()` 或 `pipe()` 之前调用。提交后再调用 `setHeader()` 会抛出 `ERR_HTTP_HEADERS_SENT`。
+ *
+ * 普通控制器应设置 `_httpCode`、调用 `_res.setHeader()` 并直接返回内容，由路由层统一提交响应头。
+ * 仅框架内部或手动接管响应（错误、重定向、代理、流式输出等）时才应直接调用本方法。
+ *
  * @param res 响应对象
- * @param statusCode 状态码
- * @param headers 头部
+ * @param statusCode HTTP 状态码
+ * @param headers 随本次提交附加的头部；通常优先在提交前使用 `setHeader()`
+ * @returns 无返回值
  */
 export declare function writeHead(res: http2.Http2ServerResponse | http.ServerResponse, statusCode: number, headers?: http.OutgoingHttpHeaders): void;
+/**
+ * --- 提交服务器发送事件（SSE）响应头 ---
+ *
+ * 在发送第一条事件前调用一次，固定提交状态码 200、事件流内容类型和禁止缓存头部。
+ * SSE 的内容长度和结束时间未知，因此不设置 `content-length`；调用后响应头已经提交，
+ * 不能再调用 `setHeader()`，后续应使用 `write()` 持续发送事件，并由调用方在结束时关闭响应。
+ *
+ * @param res 响应对象
+ * @returns 无返回值
+ */
 export declare function writeEventStreamHead(res: http2.Http2ServerResponse | http.ServerResponse): void;
 /**
  * --- 向 res 发送数据 ---

package/lib/core.js

@@ -1,7 +1,7 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2019-5-3 23:54
- * Last: 2020-4-11 22:34:58, 2022-10-2 14:13:06, 2022-12-28 20:33:24, 2023-12-15 11:49:02, 2024-7-2 15:23:35, 2025-6-13 19:45:53, 2026-05-20 09:50:00
+ * Last: 2020-4-11 22:34:58, 2022-10-2 14:13:06, 2022-12-28 20:33:24, 2023-12-15 11:49:02, 2024-7-2 15:23:35, 2025-6-13 19:45:53, 2026-05-20 09:50:00, 2026-8-22
  */
 import * as cp from 'child_process';
 import * as http2 from 'http2';
@@ -1221,10 +1221,19 @@ export function display(message, ...optionalParams) {
     console.log(`KE-DISPLAY ${lTime.format(null, 'Y-m-d H:i:s')}`, message, ...optionalParams);
 }
 /**
- * --- 让 res 发送头部（前提是头部没有被发送才能调用本方法 ---
+ * --- 提交 HTTP 响应状态和头部，兼容 HTTP/1.1 与 HTTP/2 ---
+ *
+ * `setHeader()` 只暂存或修改单个头部，不会发送响应头，也不能提交状态码；在响应头提交前可反复调用。
+ * 本方法会立即提交状态码和此前设置的全部头部，必须在所有 `setHeader()` 调用之后、首次
+ * `write()`、`end()` 或 `pipe()` 之前调用。提交后再调用 `setHeader()` 会抛出 `ERR_HTTP_HEADERS_SENT`。
+ *
+ * 普通控制器应设置 `_httpCode`、调用 `_res.setHeader()` 并直接返回内容，由路由层统一提交响应头。
+ * 仅框架内部或手动接管响应（错误、重定向、代理、流式输出等）时才应直接调用本方法。
+ *
  * @param res 响应对象
- * @param statusCode 状态码
- * @param headers 头部
+ * @param statusCode HTTP 状态码
+ * @param headers 随本次提交附加的头部；通常优先在提交前使用 `setHeader()`
+ * @returns 无返回值
  */
 export function writeHead(res, statusCode, headers) {
     if (res instanceof http2.Http2ServerResponse) {
@@ -1234,6 +1243,16 @@ export function writeHead(res, statusCode, headers) {
         res.writeHead(statusCode, headers);
     }
 }
+/**
+ * --- 提交服务器发送事件（SSE）响应头 ---
+ *
+ * 在发送第一条事件前调用一次，固定提交状态码 200、事件流内容类型和禁止缓存头部。
+ * SSE 的内容长度和结束时间未知，因此不设置 `content-length`；调用后响应头已经提交，
+ * 不能再调用 `setHeader()`，后续应使用 `write()` 持续发送事件，并由调用方在结束时关闭响应。
+ *
+ * @param res 响应对象
+ * @returns 无返回值
+ */
 export function writeEventStreamHead(res) {
     writeHead(res, 200, {
         'content-type': 'text/event-stream; charset=utf-8',

package/lib/db/conn.js

@@ -3,6 +3,7 @@ import * as lCore from '#kebab/lib/core.js';
 import * as lTime from '#kebab/lib/time.js';
 import * as lDb from '#kebab/lib/db.js';
 import * as lSqlValue from '#kebab/lib/sql/value.js';
+import * as lText from '#kebab/lib/text.js';
 // --- 注册解析器 ---
 // --- pg 库对以下类型默认返回 string，为与 MySQL 行为保持一致，在此注册解析器转为 JS 原生类型 ---
 // --- POLYGON: 返回如 ((1,1),(2,2)) 的字符串，解析为 {x, y}[] ---
@@ -301,11 +302,16 @@ export class Connection {
                 }
                 return true;
             }
-            catch {
+            catch (e) {
+                this._transaction = false;
+                this._using = false;
+                this._lost = true;
+                lCore.log({}, '[DB][Connection][beginTransaction] ' + lText.stringifyError(e), '-error');
                 return false;
             }
         }
         else {
+            lCore.log({}, '[DB][Connection][beginTransaction] connection is not in use', '-error');
             return false;
         }
     }
@@ -322,7 +328,9 @@ export class Connection {
             this._using = false;
             return true;
         }
-        catch {
+        catch (e) {
+            this._lost = true;
+            lCore.log({}, '[DB][Connection][commit] ' + lText.stringifyError(e), '-error');
             return false;
         }
     }
@@ -339,7 +347,9 @@ export class Connection {
             this._using = false;
             return true;
         }
-        catch {
+        catch (e) {
+            this._lost = true;
+            lCore.log({}, '[DB][Connection][rollback] ' + lText.stringifyError(e), '-error');
             return false;
         }
     }

package/lib/db/pool.js

@@ -8,6 +8,10 @@ import { Connection } from './conn.js';
 import { Transaction } from './tran.js';
 /** --- 连接列表池 --- */
 const connections = [];
+/** --- 开启事务最大尝试次数：首次尝试加一次换连接重试 --- */
+const BEGIN_TRANSACTION_MAX_ATTEMPTS = 2;
+/** --- 创建连接最大尝试次数：首次尝试加两次瞬时故障重试 --- */
+const CREATE_CONNECTION_MAX_ATTEMPTS = 3;
 /**
  * --- 获取当前连接池中所有连接的信息 ---
  */
@@ -157,14 +161,19 @@ export class Pool {
      * --- 开启事务，返回事务对象并锁定连接，别人任何人不可用，有 ctr 的话必传 this，独立执行时可传 null ---
      */
     async beginTransaction(ctr) {
-        const conn = await this._getConnection();
-        if (!conn) {
-            return null;
-        }
-        if (!await conn.beginTransaction()) {
-            return null;
+        for (let i = 0; i < BEGIN_TRANSACTION_MAX_ATTEMPTS; ++i) {
+            const conn = await this._getConnection();
+            if (!conn) {
+                lCore.log(ctr ?? {}, `[DB][Pool][beginTransaction] failed to get connection, service: ${lDb.ESERVICE[this._service]}, database: ${this._etc.name ?? ''}`, '-error');
+                return null;
+            }
+            if (!await conn.beginTransaction()) {
+                continue;
+            }
+            return new Transaction(ctr, conn);
         }
-        return new Transaction(ctr, conn);
+        lCore.log(ctr ?? {}, `[DB][Pool][beginTransaction] failed after retry, service: ${lDb.ESERVICE[this._service]}, database: ${this._etc.name ?? ''}`, '-error');
+        return null;
     }
     /**
      * --- 获取一个连接，自动变为 using 状态，；连接失败会返回 null ---
@@ -192,7 +201,7 @@ export class Pool {
         }
         if (!conn) {
             // --- 没有找到合适的连接，创建一个 ---
-            loop: for (let i = 0; i < 3; ++i) {
+            loop: for (let i = 0; i < CREATE_CONNECTION_MAX_ATTEMPTS; ++i) {
                 try {
                     switch (this._service) {
                         case lDb.ESERVICE.MYSQL: {
@@ -267,12 +276,13 @@ export class Pool {
                     }
                 }
                 catch (err) {
-                    if (err.message.includes('ETIMEOUT') || err.message.includes('EHOSTUNREACH') || err.message.includes('ECONNREFUSED')) {
-                        // lCore.debug(`[DB][_getConnection][${lDb.ESERVICE[this._service]}]`, err);
+                    const message = err instanceof Error ? err.message : String(err);
+                    const transient = ['ETIMEOUT', 'EHOSTUNREACH', 'ECONNREFUSED'].some(code => message.includes(code));
+                    if (transient && i < CREATE_CONNECTION_MAX_ATTEMPTS - 1) {
                         await lCore.sleep(300);
                         continue;
                     }
-                    const msg = `[DB][_getConnection][${lDb.ESERVICE[this._service]}] ${err.message}(${this._etc.host}:${this._etc.port})`;
+                    const msg = `[DB][_getConnection][${lDb.ESERVICE[this._service]}] ${message}(${this._etc.host}:${this._etc.port})`;
                     lCore.debug(msg);
                     lCore.log({}, msg, '-error');
                     break;

package/lib/text.d.ts

@@ -170,6 +170,12 @@ export declare function parseJson<T>(str: string): T | false;
  * @param space 美化方式
  */
 export declare function stringifyJson(obj: kebab.Json, space?: string | number): string;
+/**
+ * --- 将未知异常转换为适合单行日志的文本，Error 优先返回完整堆栈 ---
+ * @param error 异常对象
+ * @returns 已转义的单行错误文本
+ */
+export declare function stringifyError(error: unknown): string;
 /**
  * --- 输出文本格式的 buffer ---
  * @param buf 原始 buffer

package/lib/text.js

@@ -1,7 +1,7 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2019-5-15 16:49:39
- * Last: 2020-04-06 20:51:06, 2022-9-29 15:18:16, 2022-12-29 00:01:30, 2024-3-6 17:53:14, 2024-5-31 17:29:52, 2025-6-13 15:47:02, 2025-9-23 12:51:49
+ * Last: 2020-04-06 20:51:06, 2022-9-29 15:18:16, 2022-12-29 00:01:30, 2024-3-6 17:53:14, 2024-5-31 17:29:52, 2025-6-13 15:47:02, 2025-9-23 12:51:49, 2026-8-22
  */
 import * as net from 'net';
 import * as kebab from '#kebab/index.js';
@@ -624,6 +624,29 @@ export function stringifyJson(obj, space) {
         return v;
     }, space).replace(/"-mybigint-([-+0-9]+?)"/g, '$1');
 }
+/**
+ * --- 将未知异常转换为适合单行日志的文本，Error 优先返回完整堆栈 ---
+ * @param error 异常对象
+ * @returns 已转义的单行错误文本
+ */
+export function stringifyError(error) {
+    let message;
+    if (error instanceof Error) {
+        message = error.stack ?? error.message;
+    }
+    else if (typeof error === 'string') {
+        message = error;
+    }
+    else {
+        try {
+            message = stringifyJson(error);
+        }
+        catch {
+            message = String(error);
+        }
+    }
+    return stringifyJson(message).slice(1, -1);
+}
 /**
  * --- 输出文本格式的 buffer ---
  * @param buf 原始 buffer

package/lib/undici/request.d.ts

@@ -1,7 +1,7 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2020-4-9 20:02:39
- * Last: 2020-4-9 20:47:58, 2022-09-10 01:35:34, 2025-9-23 12:41:58
+ * Last: 2020-4-9 20:47:58, 2022-09-10 01:35:34, 2025-9-23 12:41:58, 2026-8-22
  */
 import * as stream from 'stream';
 import * as lCookie from '#kebab/lib/cookie.js';
@@ -47,6 +47,11 @@ export declare class Request {
      * @param timeout 秒
      */
     timeout(timeout: number): this;
+    /**
+     * --- 设置网络异常后的重试次数 ---
+     * @param retry 重试次数，默认为 1；非幂等请求需由调用方保证安全
+     */
+    retry(retry?: number): this;
     /**
      * --- 设置是否跟随请求方的 location，留空为跟随，不设置为不跟随 ---
      * @param follow

package/lib/undici/request.js

@@ -59,6 +59,14 @@ export class Request {
         this._opt['timeout'] = timeout;
         return this;
     }
+    /**
+     * --- 设置网络异常后的重试次数 ---
+     * @param retry 重试次数，默认为 1；非幂等请求需由调用方保证安全
+     */
+    retry(retry = 1) {
+        this._opt['retry'] = retry;
+        return this;
+    }
     /**
      * --- 设置是否跟随请求方的 location，留空为跟随，不设置为不跟随 ---
      * @param follow

package/lib/undici/response.d.ts

@@ -1,7 +1,7 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2020-4-9 15:33:06
- * Last: 2020-4-12 11:12:03, 2022-09-10 12:43:23, 2022-12-25 15:12:57, 2023-9-26 14:20:41
+ * Last: 2020-4-12 11:12:03, 2022-09-10 12:43:23, 2022-12-25 15:12:57, 2023-9-26 14:20:41, 2026-8-22
  */
 import * as undici from 'undici';
 import * as zlib from 'zlib';
@@ -31,7 +31,7 @@ export declare class Response {
     /**
      * --- 获取响应读取流对象 ---
      */
-    getStream(): (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | zlib.Gunzip | zlib.Inflate | zlib.BrotliDecompress | null;
+    getStream(): zlib.BrotliDecompress | zlib.Gunzip | zlib.Inflate | (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | null;
     /**
      * --- 获取原生响应读取流对象 ---
      */

package/lib/undici/response.js

@@ -28,7 +28,8 @@ export class Response {
             return this._req ? await lBuffer.getFull(stream) : null;
         }
         catch (e) {
-            lCore.log({}, '[Undici][Response][getContent] ' + e.message, '-error');
+            this.error = e instanceof Error ? e : new Error(String(e));
+            lCore.log({}, '[Undici][Response][getContent] ' + lText.stringifyError(e), '-error');
             return null;
         }
     }

package/lib/undici.d.ts

@@ -36,27 +36,28 @@ export declare function post(u: string, data: Record<string, kebab.Json> | Buffe
  */
 export declare function postJson(u: string, data: kebab.Json[] | Record<string, kebab.Json>, opt?: IRequestOptions): Promise<lResponse.Response>;
 /**
- * --- 发起 JSON 请求并解析 JSON 响应，失败时返回 null ---
+ * --- 发起 JSON 请求并解析 JSON 响应 ---
  * @param u 网址
  * @param data 数据
  * @param opt 选项
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
  */
-export declare function postJsonResponseJson(u: string, data: kebab.Json[] | Record<string, kebab.Json>, opt?: IRequestOptions): Promise<kebab.Json | null>;
+export declare function postJsonResponseJson(u: string, data: kebab.Json[] | Record<string, kebab.Json>, opt?: IRequestOptions): Promise<kebab.Json | null | false>;
 /**
  * --- 发起 POST 请求并解析 JSON 响应 ---
  * @param u 网址
  * @param data 数据
  * @param opt 选项
- * @returns JSON 数据，失败时返回 null
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
  */
-export declare function postResponseJson(u: string, data: Record<string, kebab.Json>, opt?: IRequestOptions): Promise<kebab.Json | null>;
+export declare function postResponseJson(u: string, data: Record<string, kebab.Json>, opt?: IRequestOptions): Promise<kebab.Json | null | false>;
 /**
  * --- 发起 GET 请求并解析 JSON 响应 ---
  * @param u 网址
  * @param opt 选项
- * @returns JSON 数据，失败时返回 null
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
  */
-export declare function getResponseJson(u: string, opt?: IRequestOptions): Promise<kebab.Json | null>;
+export declare function getResponseJson(u: string, opt?: IRequestOptions): Promise<kebab.Json | null | false>;
 /**
  * --- 发起一个完全兼容 fetch 的请求 ---
  * @param input 请求的 URL 或 Request 对象
@@ -71,6 +72,8 @@ export declare function fetch(input: string | URL | Request, init?: RequestInit
     };
     /** --- 自定义 host 映射，如 {'www.maiyun.net': '127.0.0.1'}，或全部映射到一个 host --- */
     'hosts'?: Record<string, string> | string;
+    /** --- 网络异常后的重试次数，默认 0；流式请求体不可重试，非幂等请求需由调用方保证安全 --- */
+    'retry'?: number;
 }): Promise<Response>;
 /**
  * --- 发起一个请求 ---
@@ -126,6 +129,10 @@ export interface IRequestOptions {
     'type'?: 'form' | 'json';
     /** --- 秒数，默认 300 秒 --- */
     'timeout'?: number;
+    /** --- 网络异常后的重试次数，默认 0；流式请求体不可重试，非幂等请求需由调用方保证安全 --- */
+    'retry'?: number;
+    /** --- JSON 解析失败后的重试次数，默认 0；仅适用于 ResponseJson 快捷方法，非幂等请求需由调用方保证安全 --- */
+    'retryJson'?: number;
     /** --- 追踪 location 次数，0 为不追踪，默认为 0 --- */
     'follow'?: number;
     /** --- 自定义 host 映射，如 {'www.maiyun.net': '127.0.0.1'}，或全部映射到一个 host --- */

package/lib/undici.js

@@ -26,6 +26,25 @@ function getMproxyUrl(u, mproxy) {
 }
 /** --- 复用的 undici.agent 对象列表 --- */
 const agents = new Map();
+/** --- 可重试的网络异常代码 --- */
+const retryErrorCodes = [
+    'ECONNRESET', 'ECONNREFUSED', 'ENOTFOUND', 'EAI_AGAIN', 'ENETDOWN', 'ENETUNREACH',
+    'EHOSTDOWN', 'EHOSTUNREACH', 'EPIPE', 'ETIMEDOUT', 'UND_ERR_SOCKET',
+    'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_HEADERS_TIMEOUT', 'UND_ERR_BODY_TIMEOUT'
+];
+/** --- JSON 解析重试的初始等待时间，单位毫秒 --- */
+const RETRY_JSON_MIN_TIMEOUT = 500;
+/** --- JSON 解析重试的最大等待时间，单位毫秒 --- */
+const RETRY_JSON_MAX_TIMEOUT = 30_000;
+/**
+ * --- 将重试次数规范为非负整数 ---
+ * @param retry 重试次数
+ * @returns 可执行的重试次数
+ */
+function normalizeRetry(retry) {
+    return (typeof retry === 'number') && Number.isFinite(retry) ?
+        Math.max(0, Math.floor(retry)) : 0;
+}
 /** --- 获取或创建 undici.agent 对象 --- */
 function getAgent(opt = {}) {
     let k = opt.reuse ?? 'default';
@@ -59,6 +78,26 @@ function getAgent(opt = {}) {
     }
     return agents.get(k);
 }
+/**
+ * --- 获取请求使用的 dispatcher ---
+ * @param opt 请求选项
+ * @param method 请求方法
+ * @param data 请求数据
+ * @returns 普通或带网络异常重试能力的 dispatcher
+ */
+function getDispatcher(opt, method, data) {
+    const agent = getAgent(opt);
+    const retry = normalizeRetry(opt.retry);
+    if ((retry === 0) || (data instanceof stream.Readable)) {
+        return agent;
+    }
+    return new undici.RetryAgent(agent, {
+        'maxRetries': retry,
+        'methods': [method],
+        'statusCodes': [],
+        'errorCodes': retryErrorCodes,
+    });
+}
 /**
  * --- 创建一个请求对象 ---
  * @param u
@@ -96,62 +135,70 @@ export async function postJson(u, data, opt = {}) {
     return request(u, data, opt);
 }
 /**
- * --- 发起 JSON 请求并解析 JSON 响应，失败时返回 null ---
+ * --- 发起请求并解析 JSON 响应，可在解析失败时重新请求 ---
+ * @param u 网址
+ * @param data 请求数据
+ * @param opt 请求选项
+ * @param action 日志动作名
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
+ */
+async function requestResponseJson(u, data, opt, action) {
+    const retryJson = normalizeRetry(opt.retryJson);
+    for (let i = 0; i <= retryJson; ++i) {
+        const res = await request(u, data, opt);
+        const rtn = await res.getContent();
+        if (!rtn) {
+            return null;
+        }
+        const rtnStr = rtn.toString();
+        const json = lText.parseJson(rtnStr);
+        if (json) {
+            return json;
+        }
+        if (i < retryJson) {
+            const timeout = Math.min(RETRY_JSON_MIN_TIMEOUT * (2 ** i), RETRY_JSON_MAX_TIMEOUT);
+            await lCore.sleep(timeout);
+            continue;
+        }
+        if (opt.log === undefined || opt.log) {
+            const requestData = data === undefined ? '' : `, data: ${lText.stringifyJson(data)}`;
+            lCore.log({}, `[UNDICI][${action}] parse json failed, url: ${u}${requestData}, content: ${rtnStr}`, '-neterror');
+        }
+        return false;
+    }
+    return false;
+}
+/**
+ * --- 发起 JSON 请求并解析 JSON 响应 ---
  * @param u 网址
  * @param data 数据
  * @param opt 选项
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
  */
 export async function postJsonResponseJson(u, data, opt = {}) {
     opt.method = 'POST';
     opt.type = 'json';
-    const res = await request(u, data, opt);
-    const rtn = await res.getContent();
-    if (!rtn) {
-        return null;
-    }
-    const json = lText.parseJson(rtn.toString());
-    if (!json) {
-        return null;
-    }
-    return json;
+    return requestResponseJson(u, data, opt, 'POSTJSONRESPONSEJSON');
 }
 /**
  * --- 发起 POST 请求并解析 JSON 响应 ---
  * @param u 网址
  * @param data 数据
  * @param opt 选项
- * @returns JSON 数据，失败时返回 null
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
  */
 export async function postResponseJson(u, data, opt = {}) {
     opt.method = 'POST';
-    const res = await request(u, data, opt);
-    const rtn = await res.getContent();
-    if (!rtn) {
-        return null;
-    }
-    const json = lText.parseJson(rtn.toString());
-    if (!json) {
-        return null;
-    }
-    return json;
+    return requestResponseJson(u, data, opt, 'POSTRESPONSEJSON');
 }
 /**
  * --- 发起 GET 请求并解析 JSON 响应 ---
  * @param u 网址
  * @param opt 选项
- * @returns JSON 数据，失败时返回 null
+ * @returns JSON 数据；请求失败返回 null；JSON 解析失败返回 false
  */
 export async function getResponseJson(u, opt = {}) {
-    const res = await request(u, undefined, opt);
-    const rtn = await res.getContent();
-    if (!rtn) {
-        return null;
-    }
-    const json = lText.parseJson(rtn.toString());
-    if (!json) {
-        return null;
-    }
-    return json;
+    return requestResponseJson(u, undefined, opt, 'GETRESPONSEJSON');
 }
 /**
  * --- 发起一个完全兼容 fetch 的请求 ---
@@ -244,6 +291,7 @@ export async function fetch(input, init = {}) {
         'headers': headers,
         'hosts': init.hosts,
         'mproxy': init.mproxy,
+        'retry': init.retry,
         'signal': init.signal ?? undefined,
         'follow': init.redirect === 'follow' ? 10 : 0,
     };
@@ -387,7 +435,7 @@ export async function request(u, data, opt = {}) {
             }
             return res;
         }
-        const agent = getAgent(opt);
+        const dispatcher = getDispatcher(opt, method, data);
         req = await undici.request(opt.mproxy ? getMproxyUrl(u, opt.mproxy) : u, {
             'method': method,
             'body': data,
@@ -395,7 +443,7 @@ export async function request(u, data, opt = {}) {
             'headersTimeout': timeout * 1_000,
             'bodyTimeout': timeout * 1_000,
             'signal': opt.signal,
-            'dispatcher': agent,
+            'dispatcher': dispatcher,
         });
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.15.6",
+  "version": "9.16.1",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [

package/sys/child.js

@@ -1,7 +1,7 @@
 /**
  * Project: Kebab, User: JianSuoQiYue
  * Date: 2019-5-3 23:54
- * Last: 2020-3-31 15:01:07, 2020-4-9 22:28:50, 2022-07-22 14:19:46, 2022-9-29 22:11:07, 2023-5-1 18:26:57, 2024-1-12 13:32:00, 2024-3-4 16:49:19, 2026-3-8 16:21:40
+ * Last: 2020-3-31 15:01:07, 2020-4-9 22:28:50, 2022-07-22 14:19:46, 2022-9-29 22:11:07, 2023-5-1 18:26:57, 2024-1-12 13:32:00, 2024-3-4 16:49:19, 2026-3-8 16:21:40, 2026-8-22
  */
 import * as http2 from 'http2';
 import * as tls from 'tls';
@@ -57,15 +57,18 @@ const http2Sessions = new Set();
  * @param method 请求方法
  */
 function wrapWithLinkCount(key, handler, errorPrefix, method = 'GET') {
-    linkCount[key] = (linkCount[key] ?? 0) + 1;
-    const trackId = sMonitor.track(key, method);
-    handler().catch((e) => {
-        lCore.log({}, `${errorPrefix} ${lText.stringifyJson(e.stack).slice(1, -1)}`, '-error');
+    const queryIndex = key.search(/[?#]/u);
+    /** --- 查询参数可能含敏感信息，请求计数与诊断仅保留路径 --- */
+    const requestKey = queryIndex === -1 ? key : key.slice(0, queryIndex);
+    linkCount[requestKey] = (linkCount[requestKey] ?? 0) + 1;
+    const trackId = sMonitor.track(requestKey, method);
+    Promise.resolve().then(handler).catch((e) => {
+        lCore.log({}, `${errorPrefix} ${lText.stringifyError(e)}`, '-error');
     }).finally(() => {
         sMonitor.untrack(trackId);
-        --linkCount[key];
-        if (!linkCount[key]) {
-            delete linkCount[key];
+        --linkCount[requestKey];
+        if (!linkCount[requestKey]) {
+            delete linkCount[requestKey];
         }
     });
 }
@@ -295,8 +298,8 @@ async function requestHandler(req, res, https) {
                             'req': req,
                             'get': uri.query ? lText.queryParse(uri.query) : {},
                             'cookie': {},
-                            'headers': {}
-                        }, '[CHILD][requestHandler][E0]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                            'headers': {},
+                        }, '[CHILD][requestHandler][E0]' + lText.stringifyError(e), '-error');
                         const content = '<h1>500 Server Error</h1><hr>Kebab';
                         if (!res.headersSent) {
                             res.setHeader('content-type', 'text/html; charset=utf-8');
@@ -339,7 +342,7 @@ async function requestHandler(req, res, https) {
                     }
                 }
                 catch (e) {
-                    lCore.log({}, '[CHILD][requestHandler][E1]' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+                    lCore.log({}, '[CHILD][requestHandler][E1]' + lText.stringifyError(e), '-error');
                     const content = '<h1>500 Server Error</h1><hr>Kebab';
                     if (!res.headersSent) {
                         res.setHeader('content-type', 'text/html; charset=utf-8');
@@ -618,7 +621,7 @@ process.on('message', function (msg) {
             }
         }
     })().catch(function (e) {
-        lCore.log({}, '[CHILD][process][message] ' + lText.stringifyJson(e.stack).slice(1, -1), '-error');
+        lCore.log({}, '[CHILD][process][message] ' + lText.stringifyError(e), '-error');
     });
 });
 /**