@maiyunnet/kebab 9.17.2 → 9.18.0

package/index.d.ts

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

package/index.js

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

package/lib/socket.js

@@ -17,31 +17,60 @@ export function rwebsocket(port, url, opt = {}) {
     /** --- 请求端产生的双向 socket --- */
     const server = net.createServer(socket => {
         socket.setKeepAlive(true);
+        /** --- 远程端的双向 WebSocket --- */
+        let rws = null;
+        /** --- 心跳定时器 --- */
+        let timer = null;
+        /** --- 是否已开始清理 --- */
+        let closed = false;
+        /** --- 同时清理 TCP、WebSocket 与心跳 --- */
+        const close = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            socket.destroy();
+            rws?.destroy();
+        };
+        // --- 必须在异步连接前监听，避免本地先断开后留下远端连接 ---
+        socket.on('close', close).on('error', err => {
+            lCore.display('[' + lTime.format(null, 'Y-m-d H:i:s') + '] Client error: ' + socket.remoteAddress + ':' + socket.remotePort + ', ' + err.message);
+            close();
+        });
         (async () => {
             // --- 每次进一个新连接都反代到一个新 WebSocket ---
             lCore.display('[' + lTime.format(null, 'Y-m-d H:i:s') + '] New client: ' + socket.remoteAddress + ':' + socket.remotePort);
-            /** --- 远程端的双向 websocket --- */
-            const rws = await lWs.connect(url, opt);
+            rws = await lWs.connect(url, opt);
             if (!rws) {
-                socket.end();
+                close();
+                return false;
+            }
+            if (closed) {
+                rws.destroy();
                 return false;
             }
-            const timer = setInterval(() => {
-                rws.ping();
+            timer = setInterval(() => {
+                rws?.ping();
             }, 10_000);
             rws.on('message', msg => {
                 switch (msg.opcode) {
                     case lWs.EOpcode.TEXT:
                     case lWs.EOpcode.BINARY: {
-                        socket.write(msg.data);
+                        if (!socket.write(msg.data)) {
+                            rws?.pause();
+                        }
                         break;
                     }
                     case lWs.EOpcode.CLOSE: {
-                        socket.end();
+                        close();
                         break;
                     }
                     case lWs.EOpcode.PING: {
-                        rws.pong();
+                        rws?.pong();
                         break;
                     }
                     case lWs.EOpcode.PONG: {
@@ -51,20 +80,18 @@ export function rwebsocket(port, url, opt = {}) {
                         // --- EOpcode.CONTINUATION ---
                     }
                 }
-            }).on('close', () => {
-                clearInterval(timer);
-                socket.end();
-            });
+            }).on('drain', () => {
+                socket.resume();
+            }).on('close', close);
             socket.on('data', data => {
-                rws.writeBinary(data);
-            }).on('close', () => {
-                clearInterval(timer);
-                rws.end();
+                if (rws && !rws.writeBinary(data)) {
+                    socket.pause();
+                }
+            }).on('drain', () => {
+                rws?.resume();
             }).on('end', () => {
-                rws.end();
                 lCore.display('[' + lTime.format(null, 'Y-m-d H:i:s') + '] Client disconnected: ' + socket.remoteAddress + ':' + socket.remotePort);
-            }).on('error', err => {
-                lCore.display('[' + lTime.format(null, 'Y-m-d H:i:s') + '] Client error: ' + socket.remoteAddress + ':' + socket.remotePort + ', ' + err.message);
+                close();
             });
         })().catch(() => { });
     }).listen(port, () => {

package/lib/undici/response.d.ts

@@ -31,7 +31,7 @@ export declare class Response {
     /**
      * --- 获取响应读取流对象 ---
      */
-    getStream(): zlib.BrotliDecompress | zlib.Gunzip | zlib.Inflate | (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | null;
+    getStream(): (import("undici/types/readable").default & undici.Dispatcher.BodyMixin) | zlib.Gunzip | zlib.Inflate | zlib.BrotliDecompress | null;
     /**
      * --- 获取原生响应读取流对象 ---
      */

package/lib/undici.js

@@ -636,10 +636,14 @@ export async function mproxy(ctr, auth, opt = {}) {
             });
             // --- 同时监听 close 确保 promise 一定会 resolve（客户端断连等场景） ---
             stream.pipe(res).on('close', () => {
+                stream.destroy();
                 resolve();
             });
         });
     }
+    else {
+        stream.destroy();
+    }
     return 1;
 }
 /**
@@ -739,16 +743,22 @@ export async function rproxy(ctr, route, opt = {}) {
                 // --- 同时监听 close 确保 promise 一定会 resolve（客户端断连等场景） ---
                 if (compress) {
                     stream.pipe(compress.compress).pipe(res).on('close', () => {
+                        stream.destroy();
+                        compress.compress.destroy();
                         resolve();
                     });
                 }
                 else {
                     stream.pipe(res).on('close', () => {
+                        stream.destroy();
                         resolve();
                     });
                 }
             });
         }
+        else {
+            stream.destroy();
+        }
         return true;
     }
     return false;

package/lib/ws.d.ts

@@ -43,6 +43,25 @@ export interface IConnectOptions {
         'url': string;
         'auth': string;
     };
+    /** --- WebSocket 握手失败回调 --- */
+    onConnectError?: (error: unknown) => void;
+}
+/** --- WebSocket 管道首先结束的一侧 --- */
+export type TPipeSide = 'source' | 'target';
+/** --- WebSocket 管道结束前最后收到的底层事件 --- */
+export type TPipeCloseEvent = 'close' | 'end' | 'timeout' | 'error';
+/** --- WebSocket 管道关闭信息 --- */
+export interface IPipeCloseInfo {
+    'side': TPipeSide;
+    'event': TPipeCloseEvent;
+    'error'?: unknown;
+    'code'?: number;
+    'reason'?: string;
+}
+/** --- WebSocket 关闭信息 --- */
+export interface ISocketCloseInfo {
+    'code': number;
+    'reason': string;
 }
 /** --- 正向代理请求的传入参数选项 --- */
 export interface IMproxyOptions {
@@ -78,10 +97,32 @@ export interface IRproxyOptions {
         'url': string;
         'auth': string;
     };
+    /** --- 连接目标 WebSocket 失败回调 --- */
+    onConnectError?: (error: unknown) => void;
+    /** --- 管道关闭回调，返回首先关闭的一侧及其底层事件 --- */
+    onClose?: (info: IPipeCloseInfo) => void;
+    /** --- 生成回传给另一侧的 WebSocket 关闭原因，仅在管道断开时调用 --- */
+    closeReason?: (info: IPipeCloseInfo) => string;
 }
 export declare class Socket {
     /** --- 当前的 ws 对象 --- */
     private _ws;
+    /** --- 当前是否为服务端接入的连接 --- */
+    private readonly _isServer;
+    /** --- 客户端发出的帧是否掩码 --- */
+    private _masking;
+    /** --- 等待底层写入回调的消息数量 --- */
+    private _pendingWrites;
+    /** --- 是否已经因发送缓存触发背压 --- */
+    private _writeBlocked;
+    /** --- 是否已由本端主动结束写入 --- */
+    private _finished;
+    /** --- 是否已由对端结束读取 --- */
+    private _ended;
+    /** --- 底层 TCP Socket，用于设置和清理空闲超时 --- */
+    private _transport?;
+    /** --- 底层 TCP Socket 的超时监听器 --- */
+    private _transportTimeout?;
     constructor(request?: http.IncomingMessage, socket?: net.Socket, head?: Buffer, options?: {
         'headers'?: http.OutgoingHttpHeaders;
         'timeout'?: number;
@@ -94,31 +135,85 @@ export declare class Socket {
     connect(u: string, opt?: IConnectOptions): Promise<this | null>;
     /** --- 创建成功后第一时间绑定事件 --- */
     private _bindEvent;
+    /**
+     * --- 绑定底层 TCP Socket 的空闲超时 ---
+     * @param socket 底层 TCP Socket
+     * @param timeout 超时毫秒数，0 为不超时
+     */
+    private _bindTransport;
+    /** --- 清理底层 TCP Socket 监听器 --- */
+    private _unbindTransport;
+    /**
+     * --- 将 ws 的消息数据统一转换为 Buffer ---
+     * @param data ws 原始消息数据
+     * @returns Buffer
+     */
+    private _toBuffer;
+    /**
+     * --- 接收并派发消息；上层未就绪或主动暂停时同步暂停底层 TCP 读取 ---
+     * @param msg 消息
+     */
+    private _receive;
+    /**
+     * --- 派发错误，监听器尚未绑定时暂存 ---
+     * @param error 错误对象
+     */
+    private _emitError;
     /** --- 还未开启监听时来的数据将存在这里 --- */
     private readonly _waitMsg;
+    /** --- 尚未交给消息监听器的数据量 --- */
+    private _waitMsgBytes;
+    /** --- 是否暂停向上层派发消息 --- */
+    private _paused;
     /** --- 还未开启 error 监听时产生的 error 错误对象 --- */
     private _error;
     /** --- 还未开启 close 监听时是不是就已经 close --- */
-    private _close;
+    private _close?;
     /** --- 绑定的自定义监听事件（未绑定则默认在 _bindEvent 执行） --- */
     private _on;
+    /**
+     * --- 暂存尚不能交给上层处理的消息 ---
+     * @param msg 消息
+     */
+    private _queueMessage;
+    /** --- 依次派发缓存消息，若再次发生背压则停止 --- */
+    private _flushMessages;
     /** --- 绑定监听 --- */
     on(event: 'message', cb: (msg: {
         'opcode': EOpcode;
         'data': Buffer;
     }) => void | Promise<void>): this;
     on(event: 'error', cb: (error: any) => void | Promise<void>): this;
-    on(event: 'drain' | 'close' | 'end' | 'timeout', cb: () => void | Promise<void>): this;
+    on(event: 'close', cb: (info: ISocketCloseInfo) => void | Promise<void>): this;
+    on(event: 'drain' | 'end' | 'timeout', cb: () => void | Promise<void>): this;
     /** --- 取消监听 --- */
     off(event: 'message' | 'drain' | 'error' | 'close' | 'end' | 'timeout'): this;
-    end(): void;
+    /**
+     * --- 正常结束 WebSocket 连接 ---
+     * @param code WebSocket 关闭码
+     * @param reason 关闭原因，超过协议上限时自动安全截断
+     */
+    end(code?: number, reason?: string): void;
     destroy(): void;
+    /** --- 暂停向消息监听器派发数据，并暂停底层 TCP 读取 --- */
+    pause(): void;
+    /** --- 恢复派发缓存消息，并恢复底层 TCP 读取 --- */
+    resume(): void;
     /** --- 发送文本 --- */
     writeText(data: Buffer | string | Array<Buffer | string>): boolean;
     /** --- 发送结果对象字符串 --- */
     writeResult(data: kebab.Json): boolean;
     /** --- 发送二进制 --- */
     writeBinary(data: string | Buffer | Array<string | Buffer>): boolean;
+    /**
+     * --- 发送消息并将 ws 的发送缓存转换为 Kebab 的背压布尔值 ---
+     * @param data 消息数据
+     * @param binary 是否为二进制消息
+     * @returns 是否已直接写入底层 Socket 缓存
+     */
+    private _send;
+    /** --- 发送缓存完全排空后派发 drain --- */
+    private _emitDrain;
     /** --- 当前是否是可写状态 --- */
     get writable(): boolean;
     /** --- 当前是否已经结束读取，并且无法继续读取 --- */
@@ -133,6 +228,13 @@ export declare class Socket {
     ping(data?: Buffer | string): boolean;
     /** --- 发送 ping --- */
     pong(data?: Buffer | string): boolean;
+    /**
+     * --- 发送控制帧 ---
+     * @param method 控制帧类型
+     * @param data 控制帧数据
+     * @returns 是否已直接写入底层 Socket 缓存
+     */
+    private _sendControl;
 }
 /**
  * --- 创建一个 ws 客户端发起 ws 请求 ---