@sleep2agi/commhub-server 0.9.0-preview.158 → 0.9.0-preview.159

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.158",
+  "version": "0.9.0-preview.159",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/push.test.ts

@@ -351,26 +351,36 @@ describe("real ReadableStream — byte-level backpressure (round-2 fix)", () =>
     await res.body!.cancel();
   });
 
-  test("non-reading consumer past MAX bytes triggers hard ceiling close", async () => {
+  test("non-reading consumer stops growing at COALESCE_AT and is reaped by the stuck timeout", async () => {
+    // #2363 —— 语义变更：落后超过 COALESCE_AT_BYTES 后**跳过非关键事件**，不再一路排队到
+    // 1 MB 硬顶。这样 150 条慢订阅者不会把内存放大到 连接数 × 1 MB（实测 2 GB 尖峰）。
+    // 兜底仍然存在：硬顶对这一帧的**关键帧**生效；长期不读的由 STUCK_CLOSE_MS 回收。
+    const coalesce = __SSE_INTERNALS_FOR_TEST.COALESCE_AT_BYTES;
     const ceiling = __SSE_INTERNALS_FOR_TEST.MAX_QUEUE_BACKPRESSURE_BYTES;
     const res = createSSEStream("byte-cap-probe", "net-bcp");
     const key = "net-bcp:byte-cap-probe";
     const c = __SSE_INTERNALS_FOR_TEST.clientsMap.get(key)![0];
 
-    // Push events whose total byte size exceeds the hard ceiling.
-    // With chunk-count strategy this would NOT close (each event is 1
-    // chunk; desiredSize would be at -N for N events, never -1M).
-    // With byte strategy this SHOULD close once accumulated bytes
-    // exceed ceiling.
-    const chunkSize = 100_000; // 100KB per push
-    const needed = Math.ceil(ceiling / chunkSize) + 2; // overshoot a bit
+    const chunkSize = 100_000; // 100KB per push, larger than COALESCE_AT
     const big = "x".repeat(chunkSize);
-    for (let i = 0; i < needed; i++) {
+    const before = __SSE_INTERNALS_FOR_TEST.degradedDropCount();
+    for (let i = 0; i < Math.ceil(ceiling / chunkSize) + 2; i++) {
       if (c.closed) break;
       pushEvent("byte-cap-probe", { type: "big", payload: big }, "net-bcp");
     }
+    // 关键断言 1：**没有被立刻关闭**（跳过的语义是“不排队”，不是“断开”）
+    expect(c.closed).toBe(false);
+    // 关键断言 2：队列没有一路涨到硬顶 —— 落后量被 COALESCE_AT 挡住
+    const desired = c.controller.desiredSize ?? 0;
+    expect(-desired).toBeLessThan(ceiling);
+    expect(-desired).toBeLessThanOrEqual(coalesce + chunkSize * 2);
+    // 关键断言 3：跳过被**计数**（不静默）
+    expect(__SSE_INTERNALS_FOR_TEST.degradedDropCount()).toBeGreaterThan(before);
+
+    // 关键断言 4：长期不读仍会被收回（沿用原有 stuck 回收）
+    c.stuckSince = Date.now() - (__SSE_INTERNALS_FOR_TEST.STUCK_CLOSE_MS + 1);
+    __SSE_INTERNALS_FOR_TEST.tryEnqueueBytes(c, new Uint8Array(1), { critical: true });
     expect(c.closed).toBe(true);
-    expect(__SSE_INTERNALS_FOR_TEST.clientsMap.has(key)).toBe(false);
 
     try { await res.body!.cancel(); } catch { /* already closed */ }
   });

package/src/push.ts

@@ -59,6 +59,24 @@ function envNum(k: string, fallback: number): number {
  *  half-open consumer that has stopped reading entirely. */
 const MAX_QUEUE_BACKPRESSURE_BYTES = envNum("ANET_SSE_MAX_QUEUE_BYTES", 1_000_000);
 
+/** #2363 —— 订阅者“已经落后多少字节”就不再给它非关键事件。
+ *
+ *  背景（2026-10-26 实测）：150 条慢订阅者 + 30 msg/s 广播，RSS 峰值可到 2 GB；
+ *  每条连接的上限只是 1 MB，但 300 条 × 1 MB 就是 GB 级。与其把上限一路压到底，
+ *  更合理的是：**明显落后的连接直接跳过非关键事件**（keepalive 与 connected 必须保留，
+ *  否则 liveness 探测和重连握手会失效），并计数 `sse_dropped_degraded`。
+ *
+ *  这不是“丢消息”的新语义：SSE 本来就是 best-effort，客户端重连后会拉一次快照；
+ *  真正的问题是把“慢消费者”变成“Hub 的内存账”。 */
+const COALESCE_AT_BYTES = envNum("ANET_SSE_COALESCE_AT_BYTES", 65_536);
+
+/** #2363 —— 所有广播共用同一个 TextEncoder：编码结果只读、不跨事件复用同一 Uint8Array。 */
+const SHARED_ENCODER = new TextEncoder();
+
+/** 被跳过的事件计数（进程内累计，供 /health 与测试读取）。 */
+let droppedDegraded = 0;
+export function sseDegradedDropCount(): number { return droppedDegraded; }
+
 /** How long `desiredSize` can stay negative (i.e. consumer behind HWM)
  *  before we declare the client dead. 60s by default — past 2× the
  *  keepalive interval, so a live-but-slow consumer wouldn't trip it. */
@@ -200,7 +218,7 @@ function closeClient(client: SSEClient, reason: string): void {
 /** Best-effort enqueue with backpressure guard. Returns:
  *    - "ok"    → bytes accepted, queue healthy
  *    - "dead"  → client closed; caller must remove from map */
-function tryEnqueueBytes(client: SSEClient, bytes: Uint8Array): "ok" | "dead" {
+function tryEnqueueBytes(client: SSEClient, bytes: Uint8Array, opts: { critical?: boolean } = {}): "ok" | "dead" {
   if (client.closed) return "dead";
 
   const ctrl = client.controller;
@@ -219,6 +237,14 @@ function tryEnqueueBytes(client: SSEClient, bytes: Uint8Array): "ok" | "dead" {
     return "dead";
   }
 
+  // #2363 —— 落后超过 COALESCE_AT_BYTES 且不是关键帧：跳过，不排队、也不关连接
+  // （上限之上的仍然按硬顶关闭，见上一段）。这样“慢消费者”不再把内存账单放大到
+  // 连接数 × 单连接上限，同时保留原有“彻底读不动就断开回收”的语义。
+  if (!opts.critical && desired < -COALESCE_AT_BYTES) {
+    droppedDegraded += 1;
+    return "ok";
+  }
+
   // Track stuck-since-when for the soft timeout below.
   if (desired < 0) {
     if (client.stuckSince === null) {
@@ -459,6 +485,7 @@ function createStreamForKey(
       tryEnqueueBytes(
         client,
         encoder.encode(`data: ${JSON.stringify(initialEvent)}\n\n`),
+        { critical: true },
       );
 
       // Periodic keepalive doubles as a half-open probe — if the
@@ -469,7 +496,7 @@ function createStreamForKey(
           if (client.keepaliveTimer) clearInterval(client.keepaliveTimer);
           return;
         }
-        const result = tryEnqueueBytes(client, encoder.encode(`: keepalive\n\n`));
+        const result = tryEnqueueBytes(client, encoder.encode(`: keepalive\n\n`), { critical: true });
         if (result === "ok" && isUserStreamClient(client)) touchUserSeen(client.subscriberUserId!);
         if (result === "dead") {
           // closeClient already cleared the timer; just make sure we
@@ -580,6 +607,9 @@ export function pushEvent(sessionName: string, event: Record<string, unknown>, n
   if (!arr || arr.length === 0) return;
 
   const data = `data: ${JSON.stringify(event)}\n\n`;
+  // #2363 —— 一次编码，所有订阅者共用同一份字节：150 条连接 × 每秒几十条事件时，
+  // 每连接重新 encode 一次会产生大量短命 Uint8Array（实测 150×30/s 时 RSS 峰值 2 GB）。
+  const bytes = SHARED_ENCODER.encode(data);
   let needPrune = false;
 
   for (const c of arr) {
@@ -587,7 +617,7 @@ export function pushEvent(sessionName: string, event: Record<string, unknown>, n
       needPrune = true;
       continue;
     }
-    const result = tryEnqueueBytes(c, c.encoder.encode(data));
+    const result = tryEnqueueBytes(c, bytes);
     if (result === "dead") needPrune = true;
   }
 
@@ -614,6 +644,7 @@ export function pushNetworkObserverEvent(
   if (!arr || arr.length === 0) return;
 
   const data = `data: ${JSON.stringify({ ...event, network_id: networkId, scope: "network" })}\n\n`;
+  const bytes = SHARED_ENCODER.encode(data); // #2363：一次编码，所有 observer 共用
   let needPrune = false;
 
   for (const c of arr) {
@@ -626,7 +657,7 @@ export function pushNetworkObserverEvent(
       try { pass = c.eventFilter(event); } catch { pass = false; }
       if (!pass) continue;
     }
-    const result = tryEnqueueBytes(c, c.encoder.encode(data));
+    const result = tryEnqueueBytes(c, bytes);
     if (result === "dead") needPrune = true;
   }
 
@@ -661,6 +692,7 @@ export function pushUserEvent(
   if (!arr || arr.length === 0) return;
 
   const data = `data: ${JSON.stringify({ ...event, network_id: networkId, user_id: userId, scope: "user" })}\n\n`;
+  const bytes = SHARED_ENCODER.encode(data); // #2363 同 pushEvent：一次编码共用
   let needPrune = false;
 
   for (const c of arr) {
@@ -668,7 +700,7 @@ export function pushUserEvent(
       needPrune = true;
       continue;
     }
-    const result = tryEnqueueBytes(c, c.encoder.encode(data));
+    const result = tryEnqueueBytes(c, bytes);
     if (result === "dead") needPrune = true;
   }
 
@@ -797,6 +829,8 @@ export const __SSE_INTERNALS_FOR_TEST = {
   sweepLiveness,
   closeClient,
   MAX_QUEUE_BACKPRESSURE_BYTES,
+  COALESCE_AT_BYTES,
+  degradedDropCount: sseDegradedDropCount,
   STUCK_CLOSE_MS,
   KEEPALIVE_MS,
   LIVENESS_SWEEP_MS,