@maiyunnet/kebab 9.17.1 → 9.17.3

package/index.d.ts

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

package/index.js

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

package/lib/core.d.ts

@@ -206,6 +206,15 @@ export declare function sendRestart(hosts?: string[] | 'config'): Promise<Record
     'result': boolean;
     'return': string;
 }>>;
+/**
+ * --- 向主进程（或局域网同代码机子）发送 stop 操作，停止接收新连接并在现有连接全部结束后退出 ---
+ * @param hosts 局域网主机列表，config 表示使用全局配置；不传时通知当前 master
+ * @returns 各主机发送结果
+ */
+export declare function sendStop(hosts?: string[] | 'config'): Promise<Record<string, {
+    'result': boolean;
+    'return': string;
+}>>;
 /** --- PM2 操作类型 --- */
 export type TPm2Action = 'start' | 'stop' | 'restart';
 /**
@@ -213,6 +222,7 @@ export type TPm2Action = 'start' | 'stop' | 'restart';
  * @param name PM2 进程名称
  * @param action PM2 操作类型
  * @param hosts 局域网列表
+ * @returns 各主机是否已接收并排队，不代表 PM2 操作最终执行成功
  */
 export declare function sendPm2(name: string, action?: TPm2Action, hosts?: string[] | 'config'): Promise<Record<string, {
     'result': boolean;

package/lib/core.js

@@ -713,11 +713,62 @@ export async function sendRestart(hosts) {
     }
     return rtn;
 }
+/**
+ * --- 向主进程（或局域网同代码机子）发送 stop 操作，停止接收新连接并在现有连接全部结束后退出 ---
+ * @param hosts 局域网主机列表，config 表示使用全局配置；不传时通知当前 master
+ * @returns 各主机发送结果
+ */
+export async function sendStop(hosts) {
+    if (!hosts) {
+        // --- 本地模式 ---
+        // eslint-disable-next-line no-console
+        console.log('[ Child] Sending stop request...');
+        process.send({
+            'action': 'stop'
+        });
+        return {
+            '127.0.0.1': { 'result': true, 'return': 'Done' }
+        };
+    }
+    if (hosts === 'config') {
+        hosts = globalConfig.hosts;
+    }
+    // --- 未传或 config 展开后为空数组，均回退到本机 ---
+    if (!hosts?.length) {
+        hosts = ['127.0.0.1'];
+    }
+    // --- 局域网模式 ---
+    const time = lTime.stamp();
+    /** --- 返回成功的 host --- */
+    const rtn = {};
+    for (const host of hosts) {
+        const res = await lUndici.get('http://' + host + ':' + globalConfig.rpcPort.toString() + '/' + lCrypto.aesEncrypt(lText.stringifyJson({
+            'action': 'stop',
+            'time': time
+        }), globalConfig.rpcSecret), {
+            'timeout': 5
+        });
+        const content = await res.getContent();
+        if (!content) {
+            rtn[host] = { 'result': false, 'return': 'Timeout' };
+            continue;
+        }
+        const str = content.toString();
+        if (str === 'Done') {
+            rtn[host] = { 'result': true, 'return': 'Done' };
+        }
+        else {
+            rtn[host] = { 'result': false, 'return': str };
+        }
+    }
+    return rtn;
+}
 /**
  * --- 向本机或局域网 RPC 发送 PM2 操作 ---
  * @param name PM2 进程名称
  * @param action PM2 操作类型
  * @param hosts 局域网列表
+ * @returns 各主机是否已接收并排队，不代表 PM2 操作最终执行成功
  */
 export async function sendPm2(name, action = 'restart', hosts) {
     if (hosts === 'config') {

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.d.ts

@@ -133,6 +133,8 @@ export interface IRequestOptions {
     'retry'?: number;
     /** --- JSON 解析失败后的重试次数，默认 0；仅适用于 ResponseJson 快捷方法，非幂等请求需由调用方保证安全 --- */
     'retryJson'?: number;
+    /** --- JSON 重试验证方法；返回 false 时按 retryJson 的设置重试，仅适用于 ResponseJson 快捷方法 --- */
+    'retryJsonHandler'?: (json: kebab.Json) => boolean;
     /** --- 追踪 location 次数，0 为不追踪，默认为 0 --- */
     'follow'?: number;
     /** --- 自定义 host 映射，如 {'www.maiyun.net': '127.0.0.1'}，或全部映射到一个 host --- */

package/lib/undici.js

@@ -152,7 +152,7 @@ async function requestResponseJson(u, data, opt, action) {
         }
         const rtnStr = rtn.toString();
         const json = lText.parseJson(rtnStr);
-        if (json) {
+        if (json && (opt.retryJsonHandler?.(json) ?? true)) {
             return json;
         }
         if (i < retryJson) {
@@ -162,7 +162,8 @@ async function requestResponseJson(u, data, opt, action) {
         }
         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');
+            const reason = json ? 'retry json handler returned false' : 'parse json failed';
+            lCore.log({}, `[UNDICI][${action}] ${reason}, url: ${u}${requestData}, content: ${rtnStr}`, '-neterror');
         }
         return false;
     }
@@ -635,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;
 }
 /**
@@ -738,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

@@ -96,12 +96,23 @@ export declare class Socket {
     private _bindEvent;
     /** --- 还未开启监听时来的数据将存在这里 --- */
     private readonly _waitMsg;
+    /** --- 尚未交给消息监听器的数据量 --- */
+    private _waitMsgBytes;
+    /** --- 是否暂停向上层派发消息 --- */
+    private _paused;
     /** --- 还未开启 error 监听时产生的 error 错误对象 --- */
     private _error;
     /** --- 还未开启 close 监听时是不是就已经 close --- */
     private _close;
     /** --- 绑定的自定义监听事件（未绑定则默认在 _bindEvent 执行） --- */
     private _on;
+    /**
+     * --- 暂存尚不能交给上层处理的消息 ---
+     * @param msg 消息
+     */
+    private _queueMessage;
+    /** --- 依次派发缓存消息，若再次发生背压则停止 --- */
+    private _flushMessages;
     /** --- 绑定监听 --- */
     on(event: 'message', cb: (msg: {
         'opcode': EOpcode;
@@ -113,6 +124,10 @@ export declare class Socket {
     off(event: 'message' | 'drain' | 'error' | 'close' | 'end' | 'timeout'): this;
     end(): void;
     destroy(): void;
+    /** --- 暂停向消息监听器派发数据，底层仍只保留有界缓存 --- */
+    pause(): void;
+    /** --- 恢复向消息监听器派发数据 --- */
+    resume(): void;
     /** --- 发送文本 --- */
     writeText(data: Buffer | string | Array<Buffer | string>): boolean;
     /** --- 发送结果对象字符串 --- */

package/lib/ws.js

@@ -24,6 +24,10 @@ export var EOpcode;
 const liwsServer = liws.createServer({
     'frameReceiveMode': EFrameReceiveMode.SIMPLE,
 });
+/** --- 未能及时转发的 WebSocket 消息最大缓存量，超过后关闭连接保护进程内存 --- */
+const MAX_PENDING_MESSAGE_BYTES = 8 * 1024 * 1024;
+/** --- 未能及时转发的 WebSocket 消息最大条数，防止大量小帧占满内存 --- */
+const MAX_PENDING_MESSAGES = 4_096;
 export class Socket {
     /** --- 当前的 ws 对象 --- */
     _ws;
@@ -132,19 +136,15 @@ export class Socket {
             if (!('data' in msg)) {
                 return;
             }
-            const buf = Buffer.concat(msg.data);
-            if (this._on.message) {
-                this._on.message({
-                    'opcode': msg.opcode,
-                    'data': buf,
-                });
-            }
-            else {
-                this._waitMsg.push({
-                    'opcode': msg.opcode,
-                    'data': buf,
-                });
+            const item = {
+                'opcode': msg.opcode,
+                'data': Buffer.concat(msg.data),
+            };
+            if (this._paused || !this._on.message) {
+                this._queueMessage(item);
+                return;
             }
+            this._on.message(item);
         }).on('drain', () => {
             this._on.drain?.();
         }).on('error', (e) => {
@@ -157,6 +157,8 @@ export class Socket {
         }).on('end', () => {
             this._on.end?.();
         }).on('close', () => {
+            this._waitMsg.length = 0;
+            this._waitMsgBytes = 0;
             if (this._on.close) {
                 this._on.close();
             }
@@ -169,6 +171,10 @@ export class Socket {
     }
     /** --- 还未开启监听时来的数据将存在这里 --- */
     _waitMsg = [];
+    /** --- 尚未交给消息监听器的数据量 --- */
+    _waitMsgBytes = 0;
+    /** --- 是否暂停向上层派发消息 --- */
+    _paused = false;
     /** --- 还未开启 error 监听时产生的 error 错误对象 --- */
     _error = null;
     /** --- 还未开启 close 监听时是不是就已经 close --- */
@@ -183,13 +189,44 @@ export class Socket {
         end: undefined,
         timeout: undefined,
     };
+    /**
+     * --- 暂存尚不能交给上层处理的消息 ---
+     * @param msg 消息
+     */
+    _queueMessage(msg) {
+        this._waitMsgBytes += msg.data.length;
+        if ((this._waitMsgBytes > MAX_PENDING_MESSAGE_BYTES) ||
+            (this._waitMsg.length >= MAX_PENDING_MESSAGES)) {
+            this._waitMsg.length = 0;
+            this._waitMsgBytes = 0;
+            this.destroy();
+            return;
+        }
+        this._waitMsg.push(msg);
+    }
+    /** --- 依次派发缓存消息，若再次发生背压则停止 --- */
+    _flushMessages() {
+        if (this._paused || !this._on.message || !this._waitMsg.length) {
+            return;
+        }
+        const messages = this._waitMsg.splice(0);
+        this._waitMsgBytes = 0;
+        for (let i = 0; i < messages.length; ++i) {
+            if (this._paused) {
+                for (; i < messages.length; ++i) {
+                    this._waitMsg.push(messages[i]);
+                    this._waitMsgBytes += messages[i].data.length;
+                }
+                return;
+            }
+            this._on.message(messages[i]);
+        }
+    }
     on(event, cb) {
         this._on[event] = cb;
         switch (event) {
             case 'message': {
-                for (const item of this._waitMsg) {
-                    cb(item);
-                }
+                this._flushMessages();
                 break;
             }
             case 'error': {
@@ -227,6 +264,15 @@ export class Socket {
     destroy() {
         this._ws.destroy();
     }
+    /** --- 暂停向消息监听器派发数据，底层仍只保留有界缓存 --- */
+    pause() {
+        this._paused = true;
+    }
+    /** --- 恢复向消息监听器派发数据 --- */
+    resume() {
+        this._paused = false;
+        this._flushMessages();
+    }
     /** --- 发送文本 --- */
     writeText(data) {
         if (!this._ws.writable) {
@@ -311,69 +357,93 @@ export function createServer(request, socket, head, options = {}) {
  */
 function bindPipe(s1, s2) {
     return new Promise(resolve => {
+        /** --- 是否已经完成关闭，防止双向 close 重复处理 --- */
+        let closed = false;
+        /** --- 两端一起销毁，避免半开连接继续占用资源 --- */
+        const close = () => {
+            if (closed) {
+                return;
+            }
+            closed = true;
+            s1.destroy();
+            s2.destroy();
+            resolve();
+        };
         // --- 监听发送端的 ---
         s1.on('message', (msg) => {
             switch (msg.opcode) {
                 case EOpcode.TEXT: {
-                    s2.writeText(msg.data.toString());
+                    if (!s2.writeText(msg.data.toString())) {
+                        s1.pause();
+                    }
                     break;
                 }
                 case EOpcode.BINARY: {
-                    s2.writeBinary(msg.data);
+                    if (!s2.writeBinary(msg.data)) {
+                        s1.pause();
+                    }
                     break;
                 }
                 case EOpcode.CLOSE: {
-                    s2.end();
-                    resolve();
+                    close();
                     break;
                 }
                 case EOpcode.PING: {
-                    s2.ping(msg.data);
+                    if (!s2.ping(msg.data)) {
+                        s1.pause();
+                    }
                     break;
                 }
                 case EOpcode.PONG: {
-                    s2.pong(msg.data);
+                    if (!s2.pong(msg.data)) {
+                        s1.pause();
+                    }
                     break;
                 }
                 default: {
                     // --- EOpcode.CONTINUATION ---
                 }
             }
-        }).on('close', () => {
-            s2.end();
-            resolve();
+        }).on('close', close).on('drain', () => {
+            s2.resume();
         });
         // --- 监听远程端的 ---
         s2.on('message', (msg) => {
             switch (msg.opcode) {
                 case EOpcode.TEXT: {
-                    s1.writeText(msg.data.toString());
+                    if (!s1.writeText(msg.data.toString())) {
+                        s2.pause();
+                    }
                     break;
                 }
                 case EOpcode.BINARY: {
-                    s1.writeBinary(msg.data);
+                    if (!s1.writeBinary(msg.data)) {
+                        s2.pause();
+                    }
                     break;
                 }
                 case EOpcode.CLOSE: {
-                    s1.end();
-                    resolve();
+                    close();
                     break;
                 }
                 case EOpcode.PING: {
-                    s1.ping(msg.data);
+                    if (!s1.ping(msg.data)) {
+                        s2.pause();
+                    }
                     break;
                 }
                 case EOpcode.PONG: {
-                    s1.pong(msg.data);
+                    if (!s1.pong(msg.data)) {
+                        s2.pause();
+                    }
                     break;
                 }
                 default: {
                     // --- EOpcode.CONTINUATION ---
                 }
             }
-        }).on('close', () => {
-            s1.end();
-            resolve();
+        }).on('close', close).on('drain', () => {
+            s1.resume();
         });
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "9.17.1",
+  "version": "9.17.3",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "type": "module",
   "keywords": [
@@ -35,7 +35,7 @@
     "@tailwindcss/cli": "^4.3.3",
     "@types/ssh2": "^1.15.5",
     "ajv": "^8.20.0",
-    "ajv-formats": "^3.0.1",
+    "ajv-formats": "^3.0.1", 
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "ejs": "^6.0.1",