cc-viewer 1.6.296 → 1.6.297

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-DtpelJc4.js"></script>
+  <script type="module" crossorigin src="/assets/index-Be7o3L97.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.296",
+  "version": "1.6.297",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",

package/server/lib/ask-bridge.js

@@ -40,6 +40,17 @@ if (!port) {
   process.exit(0);
 }
 
+// Opt-out: skip cc-viewer's web AskUserQuestion interception and let the prompt fall
+// through to the terminal TUI / any downstream PreToolUse|PermissionRequest hooks
+// (e.g. a desktop notifier that renders the options elsewhere). Runtime env gate,
+// mirroring CCV_BYPASS_PERMISSIONS in perm-bridge.js — the hook stays registered, so
+// this toggles per-launch with no settings.json churn. Emitting continue:true (rather
+// than exit 1) avoids Claude Code logging a "hook error" on every AskUserQuestion call.
+if (process.env.CCV_DISABLE_ASK_HOOK === '1') {
+  process.stdout.write(JSON.stringify({ continue: true, suppressOutput: true }) + '\n');
+  process.exit(0);
+}
+
 let stdinData;
 try {
   stdinData = readFileSync(0, 'utf-8');

package/server/lib/interceptor-core.js

@@ -2,7 +2,7 @@ import { appendFileSync, existsSync, readdirSync, readFileSync, statSync, unlink
 import { renameSyncWithRetry } from './file-api.js';
 import { join } from 'node:path';
 
-const SUBAGENT_SYSTEM_RE = /(?:command execution|file search|planning) specialist|general-purpose agent/i;
+const SUBAGENT_SYSTEM_RE = /(?:command execution|file search|planning) specialist|general-purpose agent|security monitor|performing a web search/i;
 
 export function getSystemText(body) {
   const system = body?.system;
@@ -36,9 +36,9 @@ export function isMainAgentRequest(body) {
   // v2.1.81+: 轻量 MainAgent 初始请求工具数可能 < 10，降低阈值兼容
   if (body.tools.length > 5) {
     const hasEdit = body.tools.some(t => t.name === 'Edit');
-    const hasBash = body.tools.some(t => t.name === 'Bash');
+    const hasShell = body.tools.some(t => t.name === 'Bash' || t.name === 'PowerShell');
     const hasTaskOrAgent = body.tools.some(t => t.name === 'Task' || t.name === 'Agent');
-    if (hasEdit && hasBash && hasTaskOrAgent) {
+    if (hasEdit && hasShell && hasTaskOrAgent) {
       return true;
     }
   }

package/server/lib/kv-cache-analyzer.js

@@ -6,7 +6,7 @@
 import { formatToolAsXml } from './tools-xml-formatter.js';
 export { formatToolAsXml };
 
-const SUBAGENT_SYSTEM_RE = /command execution specialist|file search specialist|planning specialist|general-purpose agent/i;
+const SUBAGENT_SYSTEM_RE = /command execution specialist|file search specialist|planning specialist|general-purpose agent|security monitor|performing a web search/i;
 const TEAMMATE_SYSTEM_RE = /running as an agent in a team|Agent Teammate Communication/i;
 
 function getSystemText(body) {
@@ -56,9 +56,9 @@ export function isMainAgentEntry(entry) {
   // v2.1.81+: lightweight MainAgent may have < 10 tools, lowered threshold
   if (body.tools.length > 5) {
     const hasEdit = body.tools.some(t => t.name === 'Edit');
-    const hasBash = body.tools.some(t => t.name === 'Bash');
+    const hasShell = body.tools.some(t => t.name === 'Bash' || t.name === 'PowerShell');
     const hasTaskOrAgent = body.tools.some(t => t.name === 'Task' || t.name === 'Agent');
-    if (hasEdit && hasBash && hasTaskOrAgent) return true;
+    if (hasEdit && hasShell && hasTaskOrAgent) return true;
   }
 
   return false;

package/server/lib/log-watcher.js

@@ -55,7 +55,10 @@ export function readLogFile(logFile) {
   }
 }
 
-const SSE_BACKPRESSURE_TIMEOUT_MS = 5000;
+// SSE 单客户端 backpressure 容忍上限：连续未排空 > 此时长则视为 dead 客户端剔除。
+// 与 server.js 同名常量值保持一致（避免循环依赖，此处单独 mirror）。
+// 30s：避免大会话/重连重放时把短暂忙碌的渲染器误判为 dead 并触发重连风暴，详见 server.js 注释。
+const SSE_BACKPRESSURE_TIMEOUT_MS = 30000;
 
 function _removeClient(clients, client) {
   const idx = clients.indexOf(client);

package/server/lib/ws-backpressure.js

@@ -0,0 +1,106 @@
+/**
+ * WebSocket per-client 反压闸门（Windows ConPTY 洪泛防卡死，server 侧第一道闸）。
+ *
+ * 背景：node-pty 在 Windows 经 ConPTY 把 TUI 输出转译成全屏重绘序列，字节量可达
+ * macOS forkpty 透传的 10~100 倍。onPtyData → ws.send 若不检查 ws.bufferedAmount，
+ * 慢客户端的写缓冲会无限堆积（server 内存膨胀），且数据到前端也只是堆进写队列
+ * 被丢弃。这里按 VS Code terminal / xterm.js flow-control 指南的思路做停发-追赶：
+ *
+ *   - offer()：每条 data 调用。bufferedAmount 越过 highWater → 进入 behind 态，
+ *     返回 false（调用方跳发该条）；期间 pollMs 轮询 bufferedAmount。
+ *   - 降回 lowWater 以下 → 退出 behind，调 onResume()（调用方发 data-resync +
+ *     outputBuffer 快照让前端一步对齐，无需补发洪泛期间的全部数据）。
+ *   - behind 持续超 timeoutMs（客户端网络硬断时 TCP close 可能数分钟后才到，
+ *     bufferedAmount 永不下降）→ 调 onTimeout()（调用方 ws.terminate()，前端
+ *     自动重连走全量 replay 恢复），并自行 dispose。
+ *   - 高/低水位形成迟滞带，防止在阈值附近反复开关。
+ *
+ * 纯逻辑、零 ws 依赖（bufferedAmount 由 getter 注入），便于单测。
+ */
+
+const DEFAULT_HIGH_WATER = 1024 * 1024;  // 写缓冲超 1MB：客户端已明显消费不动
+const DEFAULT_LOW_WATER = 256 * 1024;    // 降回 256KB 以下才恢复（迟滞带）
+const DEFAULT_POLL_MS = 100;             // behind 期间轮询间隔，对终端延迟无感
+const DEFAULT_TIMEOUT_MS = 60000;        // behind 超时：判定客户端死连接
+
+/**
+ * @param {object} opts
+ * @param {() => number} opts.getBufferedAmount - 返回当前 ws.bufferedAmount
+ * @param {(buffered: number) => void} opts.onResume - 退出 behind 时回调（发 data-resync）
+ * @param {(buffered: number) => void} [opts.onBehind] - 进入 behind 时回调（observability 埋点）
+ * @param {(buffered: number) => void} [opts.onTimeout] - behind 超时回调（建议 ws.terminate()）
+ * @param {number} [opts.highWater]
+ * @param {number} [opts.lowWater]
+ * @param {number} [opts.pollMs]
+ * @param {number} [opts.timeoutMs]
+ * @returns {{ offer: () => boolean, isBehind: () => boolean, dispose: () => void }}
+ */
+export function createBackpressureGate({
+  getBufferedAmount,
+  onResume,
+  onBehind,
+  onTimeout,
+  highWater = DEFAULT_HIGH_WATER,
+  lowWater = DEFAULT_LOW_WATER,
+  pollMs = DEFAULT_POLL_MS,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+}) {
+  let behind = false;
+  let pollTimer = null;
+  let behindSince = 0;
+  let disposed = false;
+
+  const stopPolling = () => {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  };
+
+  const poll = () => {
+    if (disposed) return;
+    let buffered = 0;
+    // poll 在 behind 中：读取失败按"未排空"保守处理（继续 hold，最终走超时断连）；
+    // offer 在正常态：读取失败按 0 乐观放行（不因瞬时读取失败误杀活跃连接）。方向刻意相反。
+    try { buffered = getBufferedAmount(); } catch { buffered = Infinity; }
+    if (buffered <= lowWater) {
+      behind = false;
+      stopPolling();
+      try { onResume(buffered); } catch {}
+      return;
+    }
+    if (Date.now() - behindSince >= timeoutMs) {
+      stopPolling();
+      disposed = true;
+      try { onTimeout?.(buffered); } catch {}
+    }
+  };
+
+  return {
+    /** 每条 data 调用：true = 可发；false = 跳发（behind 中） */
+    offer() {
+      if (disposed) return false;
+      if (behind) return false;
+      let buffered = 0;
+      try { buffered = getBufferedAmount(); } catch { buffered = 0; }
+      if (buffered > highWater) {
+        behind = true;
+        behindSince = Date.now();
+        pollTimer = setInterval(poll, pollMs);
+        // 进程退出不被轮询拖住（与 server.js 其余 interval 的 unref 约定一致）
+        pollTimer.unref?.();
+        try { onBehind?.(buffered); } catch {}
+        return false;
+      }
+      return true;
+    },
+    isBehind() {
+      return behind;
+    },
+    /** ws close 时调用，清掉轮询 interval */
+    dispose() {
+      disposed = true;
+      stopPolling();
+    },
+  };
+}

package/server/server.js

@@ -77,6 +77,7 @@ import { loadPlugins, runWaterfallHook, runParallelHook } from './lib/plugin-loa
 import { CONTEXT_WINDOW_FILE, readModelContextSize } from './lib/context-watcher.js';
 import { watchLogFile, startWatching, unwatchAll, sendEventToClients, sendToClients } from './lib/log-watcher.js';
 import { cleanupExtractCache } from './lib/jsonl-archive.js';
+import { createBackpressureGate } from './lib/ws-backpressure.js';
 
 
 // 动态获取 getPrefsFile()（LOG_DIR 可能在运行时被 setLogDir 修改）
@@ -292,7 +293,10 @@ const MAX_POST_BODY = 10 * 1024 * 1024;
 // 用户显式 ?limit=0 可恢复全量加载（power-user 逃生口）。
 const DEFAULT_EVENTS_LIMIT = 1000;
 // SSE 单客户端 backpressure 容忍上限：连续未排空 > 此时长则视为 dead 客户端剔除。
-const SSE_BACKPRESSURE_TIMEOUT_MS = 5000;
+// 调高至 30s：大会话首屏/重连重放时，渲染器（尤其 Windows 浏览器，大 DOM layout 更重）
+// 可能短暂忙到来不及排空 socket。过早剔除会触发「断开→EventSource 自动重连→再次重放」
+// 风暴，把瞬时卡顿放大成持续卡死。30s 仍能剔除真正死掉的连接。
+const SSE_BACKPRESSURE_TIMEOUT_MS = 30000;
 
 
 
@@ -559,7 +563,15 @@ const dispatch = createDispatcher(_routes);
 
 async function handleRequest(req, res) {
   const parsedUrl = new URL(req.url, `${serverProtocol}://${req.headers.host}`);
-  const url = parsedUrl.pathname;
+  let url = parsedUrl.pathname;
+
+  // CCV_BASE_PATH reverse proxy: strip prefix at TOP so API/WS/static/SPA
+  // all work with original unprefixed paths. basePath normalized.
+  const bpRaw = process.env.CCV_BASE_PATH || '';
+  const bp = bpRaw && bpRaw !== '/' ? bpRaw.replace(/\/?$/, '/') : '';
+  if (bp && url.startsWith(bp)) {
+    url = url.slice(bp.length) || '/';
+  }
   const method = req.method;
 
   // WebSocket 路径不处理，交给 upgrade 事件
@@ -664,7 +676,15 @@ async function handleRequest(req, res) {
 
   // 静态文件服务
   if (method === 'GET') {
-    let filePath = url === '/' ? '/index.html' : url;
+    const rawBase = process.env.CCV_BASE_PATH || '';
+    // Normalize to ensure trailing slash; prevents /proxy/ws from
+    // incorrectly matching /proxy/ws-other due to startsWith ambiguity.
+    const basePath = rawBase && rawBase !== '/' ? rawBase.replace(/\/?$/, '/') : '';
+    let filePath = url;
+    if (basePath && url.startsWith(basePath)) {
+      filePath = url.slice(basePath.length) || '/';
+    }
+    if (filePath === '/') filePath = '/index.html';
     // 去掉 query string
     filePath = filePath.split('?')[0];
 
@@ -705,6 +725,15 @@ async function handleRequest(req, res) {
           console.warn('[serveIndexHtml] dist/index.html 没有 <html data-theme="..."> 属性，SSR theme 注入将不生效。检查 index.html 模板。');
         }
         html = html.replace(/<html([^>]*?)data-theme="[^"]*"/, `<html$1data-theme="${themeColor}"`);
+        // 运行时注入 <base> 标签：当 CCV_BASE_PATH 设置为非空非根路径时，
+        // 使浏览器将所有相对 URL 解析到代理子路径下。配合 Vite base='' 输出相对路径。
+        const basePath = process.env.CCV_BASE_PATH || '';
+        if (basePath && basePath !== '/') {
+          const safeBase = basePath.replace(/\/?$/, '/');
+                  const escapedBase = safeBase.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        const jsSafeBase = safeBase.replace(/"/g, '"').replace(/<\//g, '<\/');
+        html = html.replace(/<head[^>]*>/i, m => m + `<base href="${escapedBase}"><script>window.__CCV_BASE_PATH__="${jsSafeBase}"</script>`);
+        }
         res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-cache' });
         res.end(html);
         return true;
@@ -1030,7 +1059,12 @@ async function setupTerminalWebSocket(httpServer) {
 
     httpServer.on('upgrade', (req, socket, head) => {
       const wsUrl = new URL(req.url, `${serverProtocol}://${req.headers.host}`);
-      const pathname = wsUrl.pathname;
+      let pathname = wsUrl.pathname;
+      const bpRaw = process.env.CCV_BASE_PATH || '';
+      const wsBp = bpRaw && bpRaw !== '/' ? bpRaw.replace(/\/?$/, '/') : '';
+      if (wsBp && pathname.startsWith(wsBp)) {
+        pathname = '/' + pathname.slice(wsBp.length);
+      }
       // 与 HTTP 一致的鉴权（此前 WS upgrade 完全不校验 token，远程终端实为无门禁——本次堵洞）。
       // 在此显式计算 isLocal（与 handleRequest 同款三态判断），WS 视作非 HTML 请求。
       const wsRemoteIp = req.socket.remoteAddress;
@@ -1077,6 +1111,20 @@ async function setupTerminalWebSocket(httpServer) {
       }
     });
 
+    // 反压状态转换日志（observability：线上排"页面卡"时可直接判断是否触发过反压、几次、积压量）。
+    // behind/resume 在持续洪泛下以亚秒级周期振荡，5s 节流防刷屏；timeout 是终态必记。
+    const makeBpLogger = (label, ws) => {
+      let behindCount = 0;
+      let lastLogAt = 0;
+      return (event, buffered) => {
+        if (event === 'behind') behindCount++;
+        const now = Date.now();
+        if (event !== 'timeout' && now - lastLogAt < 5000) return;
+        lastLogAt = now;
+        console.warn(`[${label}] ws backpressure ${event}: client=${ws._socket?.remoteAddress || '?'} bufferedAmount=${buffered} behindTotal=${behindCount}`);
+      };
+    };
+
     // scratch 终端 WS：极简版，仅承载 input/resize/data/exit + 显式 kill；不掺杂 hook/SDK/preset
     wssScratch.on('connection', async (ws, req) => {
       const id = req.ccvScratchId;
@@ -1097,8 +1145,27 @@ async function setupTerminalWebSocket(httpServer) {
         try { ws.send(JSON.stringify({ type: 'data', data: buffer })); } catch {}
       }
 
+      // 反压闸门：写缓冲堆积时停发 data，恢复后用 outputBuffer 快照 resync 追赶
+      // （防 Windows ConPTY 洪泛把慢客户端 / server 内存拖垮，详见 lib/ws-backpressure.js）。
+      // 快照自身有界：scratch outputBuffer 50KB 滚动截断（scratch-pty-manager.js MAX_BUFFER），
+      // behind 期间继续灌也不会撑爆 resync 响应。
+      const _bpLog = makeBpLogger('scratch-ws', ws);
+      const bpGate = createBackpressureGate({
+        getBufferedAmount: () => ws.bufferedAmount,
+        onBehind: (buffered) => _bpLog('behind', buffered),
+        onResume: (buffered) => {
+          _bpLog('resume', buffered);
+          if (ws.readyState !== 1) return;
+          try { ws.send(JSON.stringify({ type: 'data-resync', data: getScratchOutputBuffer(id) })); } catch {}
+        },
+        onTimeout: (buffered) => {
+          _bpLog('timeout', buffered);
+          try { ws.terminate(); } catch {}
+        },
+      });
+
       const removeDataListener = onScratchData(id, (data) => {
-        if (ws.readyState === 1) {
+        if (ws.readyState === 1 && bpGate.offer()) {
           try { ws.send(JSON.stringify({ type: 'data', data })); } catch {}
         }
       });
@@ -1128,6 +1195,7 @@ async function setupTerminalWebSocket(httpServer) {
       });
 
       ws.on('close', () => {
+        bpGate.dispose();
         removeDataListener();
         removeExitListener();
         // pty 本身**不杀**（保留以支持刷新重连），由 kill 消息或 /api/workspaces/stop 触发；
@@ -1174,9 +1242,48 @@ async function setupTerminalWebSocket(httpServer) {
       // 注：仅 PTY 已运行时才需要兜底；shell 不在 alternate-screen 不需要。
       let _needRedrawBootstrap = state.running === true;
 
+      // 反压闸门：写缓冲堆积时停发 data，恢复后用 outputBuffer 快照 resync 追赶；
+      // resync 后强制 claude TUI 全屏重绘，避免洪泛结束于 TUI 静止态时画面停在快照
+      // （防 Windows ConPTY 洪泛拖垮慢客户端 / server 内存，详见 lib/ws-backpressure.js）。
+      // 快照自身有界：outputBuffer 200KB 滚动截断（pty-manager.js MAX_BUFFER + findSafeSliceStart
+      // ANSI 安全起点），behind 期间 PTY 继续灌也不会撑爆 resync 响应。
+      const _bpLog = makeBpLogger('terminal-ws', ws);
+      const bpGate = createBackpressureGate({
+        getBufferedAmount: () => ws.bufferedAmount,
+        onBehind: (buffered) => _bpLog('behind', buffered),
+        onResume: (buffered) => {
+          _bpLog('resume', buffered);
+          if (ws.readyState !== 1) return;
+          try { ws.send(JSON.stringify({ type: 'data-resync', data: getOutputBuffer() })); } catch {}
+          try {
+            if (process.platform !== 'win32') {
+              // POSIX：与下方 _needRedrawBootstrap 同款 SIGWINCH 兜底
+              const pid = getClaudePid();
+              if (pid && pid !== process.pid) process.kill(pid, 'SIGWINCH');
+            } else {
+              // Windows 无 SIGWINCH：resize 抖动经 ConPTY 通知重绘（恢复路径偶发，闪烁可接受）。
+              // 尺寸仲裁与 resize 消息处理一致：移动端优先，否则活跃客户端（activeWs 为 null 时
+              // 本 ws 视为所有者）——恢复的 ws 可能是非权威的慢后台 tab，用它自己的尺寸抖动会把
+              // 共享 PTY 永久改成它的尺寸、挤掉活跃/移动端画面；无权威尺寸则跳过抖动。
+              const mSize = getMobileSize();
+              const size = mSize
+                || ((activeWs === ws || activeWs === null) ? clientSizes.get(ws) : clientSizes.get(activeWs));
+              if (size) {
+                resizePty(size.cols, size.rows + 1);
+                resizePty(size.cols, size.rows);
+              }
+            }
+          } catch {}
+        },
+        onTimeout: (buffered) => {
+          _bpLog('timeout', buffered);
+          try { ws.terminate(); } catch {}
+        },
+      });
+
       // PTY 输出 → WebSocket(合并 ws 后客户端自行按 msg.type 分发,server 端不再 role 过滤)
       const removeDataListener = onPtyData((data) => {
-        if (ws.readyState === 1) {
+        if (ws.readyState === 1 && bpGate.offer()) {
           ws.send(JSON.stringify({ type: 'data', data }));
         }
       });
@@ -1555,6 +1662,7 @@ async function setupTerminalWebSocket(httpServer) {
       });
 
       ws.on('close', () => {
+        bpGate.dispose();
         removeDataListener();
         removeExitListener();
         clientSizes.delete(ws);