cc-viewer 1.6.301 → 1.6.302

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="/assets/index-DpIkVZv8.js"></script>
+  <script type="module" crossorigin src="/assets/index-DSz9bNGm.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-Bur5ZxWE.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-Si44UqBp.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-Cco3AQJS.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.301",
+  "version": "1.6.302",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",

package/server/lib/pty-flood-coalescer.js

@@ -0,0 +1,191 @@
+/**
+ * PTY → WS 洪泛限流器（Windows ConPTY 洪泛防卡死，server 侧字节率上限）。
+ *
+ * 背景：pty-manager 的 setImmediate 合帧已把"消息数"压到每 tick 一条，但**字节量
+ * 没有上限**——ConPTY 把 TUI 全屏对话框/重绘转译成 macOS forkpty 10~100 倍的字节流
+ * （如 /theme 选择器开/关、全屏 TUI 重绘），ws-backpressure gate 只在慢网络
+ * （bufferedAmount > 1MB）介入，快 LAN 上洪泛字节全量到达前端，xterm 逐帧解析渲染
+ * 稠密 SGR+CJK 重绘把主线程打满。本器在发送侧限流：
+ *
+ *   - 直通态：chunk 立即 send（零延迟，不起 timer）。字节率按固定 flushMs 桶统计，
+ *     当前桶累计超 floodThresholdBytesPerWin → 进入限流态。打字回显 / 正常 token
+ *     流远低于阈值（≈256KB/s），不受影响。
+ *   - 限流态：chunk 剥掉自带的 DEC 2026 标记后追加进 pending（pending 内部因此
+ *     **绝无 2026 标记**，截断永不切坏配对）；每 flushMs 把 pending 用单对
+ *     SYNC_BEGIN/END 重新包裹成**一条** send 发出并清空（无论下游是否跳发，
+ *     flush 后必清——下游 bpGate 跳发时由其 data-resync 快照对齐，不在这里重试）。
+ *     发送前若 pending 超 flushBudgetBytes → findSafeSliceStart 截到尾部预算内：
+ *     这是真正的速率上限（≈ flushBudgetBytes / flushMs ≈ 1.9MB/s），与前端
+ *     TerminalWriteQueue 32KB/帧的消化速率同量级，洪泛期客户端入速 ≈ 出速不积压。
+ *     pending 超 pendingCap → 同样截到 trimTo（flush 间隔内的内存上界）。中间全屏
+ *     重绘帧 last-wins 可丢，ConPTY 重绘流自愈。findSafeSliceStart 只保 ANSI 边界、
+ *     不保 2026 配对——配平靠剥标记+重包裹兜底，截断切坏配对会让 xterm 卡在同步
+ *     缓冲态（黑屏）。scratch PTY 的 chunk 本就无 2026 标记，剥除为 no-op、重包裹
+ *     无害（不支持的终端忽略该序列），两条路径共用同一实现。
+ *   - 回落：连续 fallbackWins 个桶低于阈值 → flush 残余后回直通态。
+ *   - reset()：清 pending + timer + 回直通态。bpGate onBehind/onResume 时必须调用：
+ *     data-resync 快照（getOutputBuffer）是唯一真相源，残留 pending 若不清会把早于
+ *     快照的旧字节回灌导致画面回退。
+ *
+ * 纯逻辑、时钟可注入（setTimer/clearTimer/now），便于单测。仿 ws-backpressure.js 惯例。
+ */
+
+const SYNC_BEGIN = '\x1b[?2026h';
+const SYNC_END = '\x1b[?2026l';
+// 全局替换两种标记。pty-manager flushBatch 只在首尾各加一对，但限流态 pending 由
+// 多个 chunk 拼接而成，内部会出现多对交替——统一剥净再整体包一对。
+const SYNC_MARKS_RE = /\x1b\[\?2026[hl]/g;
+
+// 默认常量可经 CCV_FLOOD_* 环境变量覆盖（仿 CCV_FORCE_POLL 先例），便于 Windows
+// 实机排障时调参而不改源码。非法/非正整数值回落默认。
+function envInt(name, fallback) {
+  const v = parseInt(process.env[name], 10);
+  return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+
+const DEFAULT_FLUSH_MS = envInt('CCV_FLOOD_FLUSH_MS', 33);                       // 限流态合并窗口 = 字节率统计桶宽
+const DEFAULT_FLOOD_THRESHOLD = envInt('CCV_FLOOD_THRESHOLD', 8 * 1024);         // 单桶超 8KB（≈256KB/s）判定洪泛
+const DEFAULT_FALLBACK_WINS = envInt('CCV_FLOOD_FALLBACK_WINS', 3);              // 连续 N 个低于阈值的桶才回直通（迟滞）
+const DEFAULT_PENDING_CAP = envInt('CCV_FLOOD_PENDING_CAP', 256 * 1024);         // 限流态 pending 上限（flush 间隔内的内存上界）
+const DEFAULT_TRIM_TO = envInt('CCV_FLOOD_TRIM_TO', 128 * 1024);                 // pendingCap 截断后保留的尾部量
+// 单次 flush 发送预算 = 真速率上限：64KB / 33ms ≈ 1.9MB/s，与前端 32KB/帧消化速率同量级
+const DEFAULT_FLUSH_BUDGET = envInt('CCV_FLOOD_FLUSH_BUDGET', 64 * 1024);
+
+/**
+ * @param {object} opts
+ * @param {(data: string) => void} opts.send - 实际发送回调（调用方在内部接 bpGate + ws.send）
+ * @param {(buf: string, rawStart: number) => number} opts.findSafeSliceStart - ANSI 安全截断（pty-manager 导出）
+ * @param {(buffered: number) => void} [opts.onFloodStart] - 进入限流态（observability 埋点）
+ * @param {() => void} [opts.onFloodEnd] - 回落直通态
+ * @param {number} [opts.flushMs]
+ * @param {number} [opts.floodThresholdBytesPerWin]
+ * @param {number} [opts.fallbackWins]
+ * @param {number} [opts.pendingCap]
+ * @param {number} [opts.trimTo]
+ * @param {number} [opts.flushBudgetBytes]
+ * @param {(fn: Function, ms: number) => any} [opts.setTimer] - 测试注入
+ * @param {(t: any) => void} [opts.clearTimer] - 测试注入
+ * @returns {{ offer: (chunk: string) => void, reset: () => void, dispose: () => void, isFlooding: () => boolean }}
+ */
+export function createFloodCoalescer({
+  send,
+  findSafeSliceStart,
+  onFloodStart,
+  onFloodEnd,
+  flushMs = DEFAULT_FLUSH_MS,
+  floodThresholdBytesPerWin = DEFAULT_FLOOD_THRESHOLD,
+  fallbackWins = DEFAULT_FALLBACK_WINS,
+  pendingCap = DEFAULT_PENDING_CAP,
+  trimTo = DEFAULT_TRIM_TO,
+  flushBudgetBytes = DEFAULT_FLUSH_BUDGET,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout,
+}) {
+  let flooding = false;
+  let pending = '';
+  let winBytes = 0;       // 当前桶累计字节（直通态由 offer 累计，限流态由 flush 结算）
+  let calmWins = 0;       // 连续低于阈值的桶数
+  let flushTimer = null;  // 限流态周期 flush；直通态下亦作为桶边界 timer（见 offer）
+  let disposed = false;
+
+  const stopTimer = () => {
+    if (flushTimer) {
+      clearTimer(flushTimer);
+      flushTimer = null;
+    }
+  };
+
+  // 直通态的桶边界：到点清零计数。无流量时 timer 不存在，零常驻开销。
+  const armPassthroughWindow = () => {
+    if (flushTimer) return;
+    flushTimer = setTimer(() => {
+      flushTimer = null;
+      winBytes = 0;
+    }, flushMs);
+    flushTimer.unref?.();
+  };
+
+  const flushPending = () => {
+    if (!pending) return;
+    // 单次 flush 发送预算 = 真正的速率上限：超预算截到尾部（last-wins），
+    // 保证洪泛期送达客户端的字节率 ≤ flushBudgetBytes/flushMs，与前端消化速率同量级。
+    if (pending.length > flushBudgetBytes) {
+      const rawStart = pending.length - flushBudgetBytes;
+      pending = pending.slice(findSafeSliceStart(pending, rawStart));
+    }
+    const merged = SYNC_BEGIN + pending + SYNC_END;
+    pending = '';
+    try { send(merged); } catch { }
+  };
+
+  const onFloodTick = () => {
+    flushTimer = null;
+    if (disposed || !flooding) return;
+    // 本桶结算：低于阈值累计 calm 桶数，连续 fallbackWins 个即回落
+    if (winBytes <= floodThresholdBytesPerWin) {
+      calmWins++;
+    } else {
+      calmWins = 0;
+    }
+    winBytes = 0;
+    flushPending();
+    if (calmWins >= fallbackWins) {
+      flooding = false;
+      calmWins = 0;
+      try { onFloodEnd?.(); } catch { }
+      return; // 不再续约 timer，回直通
+    }
+    flushTimer = setTimer(onFloodTick, flushMs);
+    flushTimer.unref?.();
+  };
+
+  return {
+    /** 每条 PTY chunk 调用。直通态立即 send；限流态进 pending 等周期 flush。 */
+    offer(chunk) {
+      if (disposed || !chunk) return;
+      winBytes += chunk.length;
+      if (!flooding) {
+        if (winBytes > floodThresholdBytesPerWin) {
+          // 进入限流态：当前 chunk 是压垮桶的那条，一并纳入 pending（含它之前
+          // 本桶已直通的部分不回收——它们已发出，量级在阈值内）。
+          flooding = true;
+          calmWins = 0;
+          stopTimer();
+          pending = chunk.replace(SYNC_MARKS_RE, '');
+          flushTimer = setTimer(onFloodTick, flushMs);
+          flushTimer.unref?.();
+          try { onFloodStart?.(winBytes); } catch { }
+          return;
+        }
+        armPassthroughWindow();
+        try { send(chunk); } catch { }
+        return;
+      }
+      pending += chunk.replace(SYNC_MARKS_RE, '');
+      // 单 chunk 可超 cap：pty-manager 每 tick 合帧，一个 tick（如 /resume 重放）可达数百 KB，
+      // 故该分支并非不可达——它是 flush 间隔内的内存上界，与 flushPending 的速率预算各司其职。
+      if (pending.length > pendingCap) {
+        const rawStart = pending.length - trimTo;
+        const safeStart = findSafeSliceStart(pending, rawStart);
+        pending = pending.slice(safeStart);
+      }
+    },
+    /** bpGate onBehind/onResume 时调用：resync 快照是唯一真相源，清掉旧 pending 防回灌。 */
+    reset() {
+      stopTimer();
+      pending = '';
+      winBytes = 0;
+      calmWins = 0;
+      flooding = false;
+    },
+    isFlooding() {
+      return flooding;
+    },
+    /** ws close 时调用，终态。 */
+    dispose() {
+      disposed = true;
+      stopTimer();
+      pending = '';
+    },
+  };
+}

package/server/pty-manager.js

@@ -47,8 +47,11 @@ async function getPty() {
  * 在 outputBuffer 截断时，找到安全的截断位置，
  * 避免从 ANSI 转义序列中间开始导致终端状态紊乱。
  * 策略：从截断点向后扫描，跳过可能被截断的不完整转义序列。
+ * 注意：只保 ANSI 序列边界，不保 DEC 2026 同步标记的配对——
+ * 跨 2026 块截断的配平由调用方负责（见 lib/pty-flood-coalescer.js）。
+ * export 供洪泛限流器复用同一截断语义。
  */
-function findSafeSliceStart(buf, rawStart) {
+export function findSafeSliceStart(buf, rawStart) {
   // 从 rawStart 开始，向后最多扫描 64 字节寻找安全起点
   const scanLimit = Math.min(rawStart + 64, buf.length);
   let i = rawStart;

package/server/routes/files-fs.js

@@ -560,8 +560,12 @@ function revealFile(req, res, parsedUrl, isLocal, deps) {
       if (plat === 'darwin') {
         execFile('open', ['-R', fullPath], () => {});
       } else if (plat === 'win32') {
-        // explorer /select,<path> 必须合到一个 arg；分两个会让含空格/中文路径 escape 失败。
-        spawn('explorer.exe', [`/select,${fullPath}`], { shell: false, windowsHide: true });
+        // explorer /select 的规范形式是 /select,"<path>"（仅路径部分加引号、整体一个 arg）。
+        // 必须 windowsVerbatimArguments 透传：否则 Node 对含空格 arg 整体加引号生成
+        // explorer.exe "/select,C:\My Proj\x.txt"，explorer 解析不了 → 功能失效。
+        // Windows 文件名不允许 "，且不经 cmd.exe，无元字符注入面。
+        const child = spawn('explorer.exe', [`/select,"${fullPath}"`], { windowsVerbatimArguments: true, windowsHide: true });
+        child.on('error', () => {}); // 防 async ENOENT 变 uncaughtException 砸进程
       } else {
         execFile('xdg-open', [dirname(fullPath)], () => {});
       }

package/server/routes/preferences.js

@@ -18,6 +18,14 @@ function stripImConfigs(obj) {
   if (obj) for (const id of listPlatforms()) delete obj[id];
 }
 
+// /theme 选择器特征：选项文案高特异、不太可能出现在普通生成输出里（ESC 兜底的门控签名）
+const THEME_PICKER_RE = /Auto \(match terminal\)|colorblind-friendly/;
+
+// 并发切主题防重入：双端同时 POST themeColor 时只允许一条 /theme 同步链路在途，
+// 防止双监听器 + 双 /theme 注入 + 双 ESC（后到的 POST 仅落盘偏好，跳过 PTY 同步）。
+let _themeSyncInFlight = false;
+export function _resetThemeSyncForTests() { _themeSyncInFlight = false; }
+
 function preferencesGet(req, res, parsedUrl, isLocal, deps) {
   let prefs = {};
   try { if (existsSync(deps.getPrefsFile())) prefs = JSON.parse(readFileSync(deps.getPrefsFile(), 'utf-8')); } catch { }
@@ -84,11 +92,18 @@ function preferencesPost(req, res, parsedUrl, isLocal, deps) {
       // preferences.json 可能携带 auth 的 base64 密码 —— 与 lib/auth.js writePrefs 一致地
       // 重申 0600,避免该路径(无 mode/不 chmod)把密码文件留成默认 umask 的可读权限。
       try { chmodSync(prefsFile, 0o600); } catch { /* best-effort; non-POSIX or race */ }
-      // 主题切换时同步到 Claude Code CLI：发 /theme，监听输出验证结果，不对就再发一次
-      if (incoming.themeColor && deps.writeToPty && deps.onPtyData) {
+      // 主题切换时同步到 Claude Code CLI：发 /theme，监听输出验证结果。
+      // 现代 CLI（≥2.x）的 /theme 是交互式选择器（args 被忽略），注入后对话框可能
+      // 残留在终端：
+      //   - mismatch 时**不再重发** /theme —— toggle 语义已不存在，重发只会把选择器
+      //     再次打开，把终端困进"确认-重开"循环（Windows ConPTY 下每轮全屏重绘洪泛）。
+      //   - 5s 超时若 buf 检出选择器特征（选项文案，见 THEME_PICKER_RE），补发一次
+      //     ESC 关闭残留对话框。无特征绝不发 ESC —— CLI 正在流式生成时 /theme 只是被
+      //     排队、对话框未开，误发 ESC 会 interrupt 用户正在跑的任务（宁漏关不误发）。
+      if (incoming.themeColor && deps.writeToPty && deps.onPtyData && !_themeSyncInFlight) {
+        _themeSyncInFlight = true;
         const target = incoming.themeColor === 'light' ? 'light' : 'dark';
         let buf = '';
-        let retried = false;
         const removeListener = deps.onPtyData((data) => {
           buf += data;
           if (buf.length > 4096) buf = buf.slice(-2048); // 限制 buf 大小
@@ -97,15 +112,20 @@ function preferencesPost(req, res, parsedUrl, isLocal, deps) {
           if (match) {
             removeListener();
             clearTimeout(timeout);
-            if (match[1] !== target && !retried) {
-              // 结果与目标不一致，再 toggle 一次
-              retried = true;
-              try { deps.writeToPty('/theme\r'); } catch {}
+            _themeSyncInFlight = false;
+            if (match[1] !== target) {
+              console.warn(`[preferences] CLI theme sync mismatch: got ${match[1]}, wanted ${target} (no retry; modern /theme is an interactive picker)`);
             }
           }
         });
-        // 5 秒超时，避免监听器泄漏
-        const timeout = setTimeout(() => { removeListener(); }, 5000);
+        // 5 秒超时，避免监听器泄漏；检出选择器残留时 ESC 兜底关闭
+        const timeout = setTimeout(() => {
+          removeListener();
+          _themeSyncInFlight = false;
+          if (THEME_PICKER_RE.test(buf)) {
+            try { deps.writeToPty('\x1b'); } catch {}
+          }
+        }, 5000);
         try { deps.writeToPty('/theme\r'); } catch {}
       }
       // 回显里也剥离 auth/authByProject(含 base64 密码) —— GET 已剥离,POST 回显同样不能漏给

package/server/server.js

@@ -81,6 +81,7 @@ import { backupConfigs } from './lib/config-backup.js';
 import { normalizeBasePath, validateBasePath, stripBasePath } from './lib/base-path.js';
 import { createHardenedCleanup } from './lib/term-signals.js';
 import { createBackpressureGate } from './lib/ws-backpressure.js';
+import { createFloodCoalescer } from './lib/pty-flood-coalescer.js';
 
 
 // 动态获取 getPrefsFile()（LOG_DIR 可能在运行时被 setLogDir 修改）
@@ -1027,7 +1028,7 @@ export async function startViewer() {
 async function setupTerminalWebSocket(httpServer) {
   try {
     const { WebSocketServer } = await import('ws');
-    const { writeToPty, writeToPtySequential, resizePty, onPtyData, onPtyExit, getPtyState, getOutputBuffer, getCurrentWorkspace, spawnShell } = await import('./pty-manager.js');
+    const { writeToPty, writeToPtySequential, resizePty, onPtyData, onPtyExit, getPtyState, getOutputBuffer, getCurrentWorkspace, spawnShell, findSafeSliceStart } = await import('./pty-manager.js');
     const {
       spawnScratch,
       writeScratch,
@@ -1132,6 +1133,20 @@ async function setupTerminalWebSocket(httpServer) {
       };
     };
 
+    // 洪泛限流器状态日志（与 makeBpLogger 同款 5s 节流，独立实例不共享计数）。
+    // Windows 实机排"切主题/大流量卡死"时据此确认 ConPTY 洪泛是否触发、几次、量级。
+    const makeFloodLogger = (label, ws) => {
+      let floodCount = 0;
+      let lastLogAt = 0;
+      return (event, bytes) => {
+        if (event === 'start') floodCount++;
+        const now = Date.now();
+        if (now - lastLogAt < 5000) return;
+        lastLogAt = now;
+        console.warn(`[${label}] pty flood ${event}: client=${ws._socket?.remoteAddress || '?'} winBytes=${bytes} floodTotal=${floodCount}`);
+      };
+    };
+
     // scratch 终端 WS：极简版，仅承载 input/resize/data/exit + 显式 kill；不掺杂 hook/SDK/preset
     wssScratch.on('connection', async (ws, req) => {
       const id = req.ccvScratchId;
@@ -1157,11 +1172,18 @@ async function setupTerminalWebSocket(httpServer) {
       // 快照自身有界：scratch outputBuffer 50KB 滚动截断（scratch-pty-manager.js MAX_BUFFER），
       // behind 期间继续灌也不会撑爆 resync 响应。
       const _bpLog = makeBpLogger('scratch-ws', ws);
+      // floodGate 在 bpGate 之后构造（send 闭包依赖 bpGate），onBehind/onResume 经 let 前向引用 reset：
+      // resync 快照是唯一真相源，coalescer 残留 pending 不清会把早于快照的旧字节回灌导致画面回退。
+      let floodGate = null;
       const bpGate = createBackpressureGate({
         getBufferedAmount: () => ws.bufferedAmount,
-        onBehind: (buffered) => _bpLog('behind', buffered),
+        onBehind: (buffered) => {
+          _bpLog('behind', buffered);
+          floodGate?.reset();
+        },
         onResume: (buffered) => {
           _bpLog('resume', buffered);
+          floodGate?.reset();
           if (ws.readyState !== 1) return;
           try { ws.send(JSON.stringify({ type: 'data-resync', data: getScratchOutputBuffer(id) })); } catch {}
         },
@@ -1171,10 +1193,22 @@ async function setupTerminalWebSocket(httpServer) {
         },
       });
 
+      // 洪泛限流器：字节率超阈值时按窗口合并 + last-wins 截断（ConPTY 全屏重绘洪泛防卡死，
+      // 与 bpGate 互补——bpGate 管慢网络写缓冲，floodGate 管快 LAN 字节率，详见 lib/pty-flood-coalescer.js）
+      const _floodLog = makeFloodLogger('scratch-ws', ws);
+      floodGate = createFloodCoalescer({
+        send: (data) => {
+          if (ws.readyState === 1 && bpGate.offer()) {
+            try { ws.send(JSON.stringify({ type: 'data', data })); } catch {}
+          }
+        },
+        findSafeSliceStart,
+        onFloodStart: (bytes) => _floodLog('start', bytes),
+        onFloodEnd: () => _floodLog('end', 0),
+      });
+
       const removeDataListener = onScratchData(id, (data) => {
-        if (ws.readyState === 1 && bpGate.offer()) {
-          try { ws.send(JSON.stringify({ type: 'data', data })); } catch {}
-        }
+        floodGate.offer(data);
       });
 
       const removeExitListener = onScratchExit(id, (exitCode) => {
@@ -1203,6 +1237,7 @@ async function setupTerminalWebSocket(httpServer) {
 
       ws.on('close', () => {
         bpGate.dispose();
+        floodGate.dispose();
         removeDataListener();
         removeExitListener();
         // pty 本身**不杀**（保留以支持刷新重连），由 kill 消息或 /api/workspaces/stop 触发；
@@ -1255,11 +1290,18 @@ async function setupTerminalWebSocket(httpServer) {
       // 快照自身有界：outputBuffer 200KB 滚动截断（pty-manager.js MAX_BUFFER + findSafeSliceStart
       // ANSI 安全起点），behind 期间 PTY 继续灌也不会撑爆 resync 响应。
       const _bpLog = makeBpLogger('terminal-ws', ws);
+      // floodGate 前向引用（构造顺序同 scratch 路径）：onBehind/onResume 必清 coalescer
+      // pending——resync 快照是唯一真相源，旧 pending 回灌会导致画面回退。
+      let floodGate = null;
       const bpGate = createBackpressureGate({
         getBufferedAmount: () => ws.bufferedAmount,
-        onBehind: (buffered) => _bpLog('behind', buffered),
+        onBehind: (buffered) => {
+          _bpLog('behind', buffered);
+          floodGate?.reset();
+        },
         onResume: (buffered) => {
           _bpLog('resume', buffered);
+          floodGate?.reset();
           if (ws.readyState !== 1) return;
           try { ws.send(JSON.stringify({ type: 'data-resync', data: getOutputBuffer() })); } catch {}
           try {
@@ -1288,11 +1330,23 @@ async function setupTerminalWebSocket(httpServer) {
         },
       });
 
+      // 洪泛限流器：字节率超阈值时按窗口合并 + last-wins 截断（ConPTY 全屏重绘洪泛防卡死，
+      // 与 bpGate 互补——bpGate 管慢网络写缓冲，floodGate 管快 LAN 字节率，详见 lib/pty-flood-coalescer.js）
+      const _floodLog = makeFloodLogger('terminal-ws', ws);
+      floodGate = createFloodCoalescer({
+        send: (data) => {
+          if (ws.readyState === 1 && bpGate.offer()) {
+            try { ws.send(JSON.stringify({ type: 'data', data })); } catch {}
+          }
+        },
+        findSafeSliceStart,
+        onFloodStart: (bytes) => _floodLog('start', bytes),
+        onFloodEnd: () => _floodLog('end', 0),
+      });
+
       // PTY 输出 → WebSocket(合并 ws 后客户端自行按 msg.type 分发,server 端不再 role 过滤)
       const removeDataListener = onPtyData((data) => {
-        if (ws.readyState === 1 && bpGate.offer()) {
-          ws.send(JSON.stringify({ type: 'data', data }));
-        }
+        floodGate.offer(data);
       });
 
       // PTY 退出 → WebSocket
@@ -1670,6 +1724,7 @@ async function setupTerminalWebSocket(httpServer) {
 
       ws.on('close', () => {
         bpGate.dispose();
+        floodGate.dispose();
         removeDataListener();
         removeExitListener();
         clientSizes.delete(ws);