cc-viewer 1.6.294 → 1.6.296

package/server/lib/log-stream.js

@@ -11,6 +11,7 @@
  */
 
 import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { open as fsOpen, stat as fsStat } from 'node:fs/promises';
 import { isCheckpointEntry, isDeltaEntry, reconstructSegment } from './delta-reconstructor.js';
 import { resolveJsonlPath } from './jsonl-archive.js';
 
@@ -56,15 +57,55 @@ function* iterateRawEntries(filePath) {
   }
 }
 
+/**
+ * 异步 Generator：分块读取 JSONL 文件，逐条 yield 原始 JSON 字符串。
+ * 使用 fs.promises.open + fileHandle.read，不阻塞事件循环。
+ */
+async function* iterateRawEntriesAsync(filePath) {
+  filePath = resolveJsonlPath(filePath);
+  let fh;
+  try {
+    const st = await fsStat(filePath);
+    if (st.size === 0) return;
+    fh = await fsOpen(filePath, 'r');
+    const fileSize = st.size;
+    const buf = Buffer.alloc(Math.min(READ_CHUNK_SIZE, fileSize));
+    let offset = 0;
+    let pending = '';
+
+    while (offset < fileSize) {
+      const toRead = Math.min(buf.length, fileSize - offset);
+      const { bytesRead } = await fh.read(buf, 0, toRead, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+
+      const raw = pending + buf.toString('utf-8', 0, bytesRead);
+      const parts = raw.split(SEPARATOR);
+      pending = parts.pop() || '';
+
+      for (const part of parts) {
+        const trimmed = part.trim();
+        if (trimmed) yield trimmed;
+      }
+    }
+
+    if (pending.trim()) {
+      yield pending.trim();
+    }
+  } finally {
+    if (fh) await fh.close();
+  }
+}
+
 /**
  * 轻量预扫描：统计条目总数（原始条目数，不去重）。
  * 用于 SSE load_start 的 total 字段（进度显示）。
  */
-export function countLogEntries(filePath) {
+export async function countLogEntries(filePath) {
   filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return 0;
   let count = 0;
-  for (const _ of iterateRawEntries(filePath)) { count++; }
+  for await (const _ of iterateRawEntriesAsync(filePath)) { count++; }
   return count;
 }
 
@@ -157,6 +198,61 @@ export function streamReconstructedEntries(filePath, onSegment, opts = {}) {
   return sentCount;
 }
 
+export async function streamReconstructedEntriesAsync(filePath, onSegment, opts = {}) {
+  filePath = resolveJsonlPath(filePath);
+  if (!existsSync(filePath)) return 0;
+  try {
+    const st = await fsStat(filePath);
+    if (st.size === 0) return 0;
+  } catch { return 0; }
+
+  const sinceMs = opts.since ? new Date(opts.since).getTime() : 0;
+  let currentSegment = [];
+  let dedup = new Map();
+  let sentCount = 0;
+
+  async function flushSegment(nextCp) {
+    if (currentSegment.length === 0) return;
+    const dedupedSegment = Array.from(dedup.values());
+    reconstructSegment(dedupedSegment, nextCp);
+
+    let toSend = dedupedSegment;
+    if (sinceMs) {
+      toSend = dedupedSegment.filter(e => {
+        const ts = e.timestamp ? new Date(e.timestamp).getTime() : 0;
+        return ts > sinceMs;
+      });
+    }
+    if (toSend.length > 0) {
+      await onSegment(toSend);
+      sentCount += toSend.length;
+    }
+    currentSegment = [];
+    dedup = new Map();
+  }
+
+  for await (const rawEntry of iterateRawEntriesAsync(filePath)) {
+    let entry;
+    try { entry = JSON.parse(rawEntry); } catch { continue; }
+
+    if (isSegmentBoundary(entry) && currentSegment.length > 0) {
+      const key = `${entry.timestamp}|${entry.url}`;
+      const last = currentSegment[currentSegment.length - 1];
+      const lastKey = `${last.timestamp}|${last.url}`;
+      if (key !== lastKey) {
+        await flushSegment(entry);
+      }
+    }
+
+    const key = `${entry.timestamp}|${entry.url}`;
+    dedup.set(key, entry);
+    currentSegment.push(entry);
+  }
+
+  await flushSegment(null);
+  return sentCount;
+}
+
 // ============================================================================
 // 异步 API — 用于 SSE/HTTP：不做重建，直接发原始 JSON 字符串
 // ============================================================================
@@ -192,16 +288,15 @@ export async function streamRawEntriesAsync(filePath, onRawEntry, opts = {}) {
   const onScan = opts.onScan || null;
   const onReady = opts.onReady || null;
 
-  // 第一遍：generator 逐条读取 → dedup Map 存原始字符串（不 parse）
+  // 第一遍：异步 generator 逐条读取 → dedup Map 存原始字符串（不 parse）
   // 内存 = 去重后的原始字符串总量 ≈ 文件大小的一半（inProgress 被 completed 覆盖）
   const dedup = new Map();
-  for (const raw of iterateRawEntries(filePath)) {
+  for await (const raw of iterateRawEntriesAsync(filePath)) {
     if (onScan) onScan(raw);
     const key = extractDedupKey(raw);
     if (key) {
       dedup.set(key, raw);
     } else {
-      // 无法提取 key 的条目直接保留（用自增 id 避免被覆盖）
       dedup.set(`__nokey_${dedup.size}`, raw);
     }
   }
@@ -270,15 +365,14 @@ export async function streamRawEntriesAsync(filePath, onRawEntry, opts = {}) {
  * @param {{ before: string, limit: number }} opts
  * @returns {{ entries: string[], hasMore: boolean, oldestTimestamp: string, count: number }}
  */
-export function readPagedEntries(filePath, { before, limit }) {
+export async function readPagedEntries(filePath, { before, limit }) {
   filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };
   const stat = statSync(filePath);
   if (stat.size === 0) return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };
 
-  // 去重
   const dedup = new Map();
-  for (const raw of iterateRawEntries(filePath)) {
+  for await (const raw of iterateRawEntriesAsync(filePath)) {
     const key = extractDedupKey(raw);
     if (key) {
       dedup.set(key, raw);

package/server/lib/log-watcher.js

@@ -1,22 +1,33 @@
-import { readFileSync, existsSync, watchFile, unwatchFile, openSync, readSync, closeSync, statSync } from 'node:fs';
+import { readFileSync, existsSync, watch, watchFile, unwatchFile, statSync } from 'node:fs';
+import { open as fsOpen, stat as fsStat } from 'node:fs/promises';
+import { dirname, basename } from 'node:path';
 import { isMainAgentEntry, extractCachedContent } from './kv-cache-analyzer.js';
 import { buildContextWindowEvent, getContextSizeForModel } from './context-watcher.js';
 import { reconstructEntries, createIncrementalReconstructor } from './delta-reconstructor.js';
-import { countLogEntries, streamReconstructedEntries } from './log-stream.js';
+import { countLogEntries, streamReconstructedEntriesAsync } from './log-stream.js';
 import { enrichEntry } from './enrich-plan-input.js';
 import { resolveJsonlPath } from './jsonl-archive.js';
 
-// 跟踪所有被 watch 的日志文件
+// 跟踪所有被 watch 的日志文件。value: fileState 对象（外部只用 .has()/.keys()）
 const watchedFiles = new Map();
 
+// 目录级 fs.watch 实例注册表（事件驱动，替代 per-file 轮询）
+const _dirWatchers = new Map();
+
+// Windows 单次 appendFileSync 触发 2+ 事件，防抖合并
+const FSWATCH_DEBOUNCE_MS = 80;
+
+// 安全网慢轮询：fs.watch 可能漏事件（buffer overflow 等），冷 fallback 兜底
+const SAFETY_POLL_MS = 5000;
+
+const FORCE_POLL = process.env.CCV_FORCE_POLL === '1';
+
 /**
  * Read and parse a JSONL log file.
  * @param {string} logFile - absolute path to the log file
  * @returns {Array} parsed and deduplicated entries
  */
 export function readLogFile(logFile) {
-  // 透明支持归档后的 .jsonl.zip。active log（被 watchLogFile 追加写入的文件）不会被归档
-  // （archive 拒绝最新文件），watchLogFile 内部的 openSync/readSync 因此无需走 resolveJsonlPath。
   logFile = resolveJsonlPath(logFile);
   if (!existsSync(logFile)) {
     return [];
@@ -24,8 +35,6 @@ export function readLogFile(logFile) {
 
   try {
     const content = readFileSync(logFile, 'utf-8');
-    // Windows 上若 writer 使用 os.EOL，分隔符会变 \r\n---\r\n。固定 LF 切会失败 → 整文件
-    // 解析成一条乱码或漏。CRLF-tolerant split 把两边都 cover 住。
     const entries = content.split(/\r?\n---\r?\n/).filter(line => line.trim());
     const parsed = entries.map(entry => {
       try {
@@ -34,7 +43,6 @@ export function readLogFile(logFile) {
         return null;
       }
     }).filter(Boolean);
-    // 去重：同一 timestamp+url 的条目，后出现的（带 response）覆盖先出现的（在途）
     const map = new Map();
     for (const entry of parsed) {
       const key = `${entry.timestamp}|${entry.url}`;
@@ -47,8 +55,6 @@ export function readLogFile(logFile) {
   }
 }
 
-// SSE 单客户端 backpressure 容忍上限：连续未排空 > 此时长则视为 dead 客户端剔除。
-// 与 server.js 同名常量值保持一致（避免循环依赖，此处单独 mirror）。
 const SSE_BACKPRESSURE_TIMEOUT_MS = 5000;
 
 function _removeClient(clients, client) {
@@ -56,14 +62,7 @@ function _removeClient(clients, client) {
   if (idx !== -1) clients.splice(idx, 1);
 }
 
-/**
- * 向单个 SSE client 安全写入 payload。
- * - 写错或 client.destroyed/!writable：立即从 clients 数组移除
- * - write 返回 false（写缓冲满）：标记时间戳，超过 SSE_BACKPRESSURE_TIMEOUT_MS 仍未排空则剔除并 end()
- * - drain 后重置 _sseBackpressureSince=0，下次 backpressure 重新计时
- */
 function _safeSseWrite(clients, client, payload) {
-  // 仅在显式标记 destroyed/writable=false 时剔除；undefined（如老 mock）按"活"处理。
   if (client.destroyed === true || client.writable === false) {
     _removeClient(clients, client);
     return false;
@@ -88,25 +87,13 @@ function _safeSseWrite(clients, client, payload) {
   return true;
 }
 
-/**
- * Send an SSE entry to all connected clients.
- * @param {Array} clients - SSE client array
- * @param {object} entry - parsed log entry
- */
 export function sendToClients(clients, entry) {
   const payload = `data: ${JSON.stringify(entry)}\n\n`;
-  // 倒序遍历允许循环内安全 splice
   for (let i = clients.length - 1; i >= 0; i--) {
     _safeSseWrite(clients, clients[i], payload);
   }
 }
 
-/**
- * Send a named SSE event to all connected clients.
- * @param {Array} clients - SSE client array
- * @param {string} eventName - SSE event name
- * @param {object} data - event payload
- */
 export function sendEventToClients(clients, eventName, data) {
   const payload = `event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`;
   for (let i = clients.length - 1; i >= 0; i--) {
@@ -114,11 +101,6 @@ export function sendEventToClients(clients, eventName, data) {
   }
 }
 
-/**
- * 旋转处理器专用：发送已序列化的 load_chunk segment 数据。
- * @param {Array} clients - SSE client array
- * @param {string} dataJson - segment 已被调用方 JSON.stringify
- */
 export function sendChunkToClients(clients, dataJson) {
   const payload = `event: load_chunk\ndata: ${dataJson}\n\n`;
   for (let i = clients.length - 1; i >= 0; i--) {
@@ -126,24 +108,185 @@ export function sendChunkToClients(clients, dataJson) {
   }
 }
 
-/**
- * Watch a log file for changes and broadcast new entries.
- * @param {object} opts
- * @param {string} opts.logFile - log file to watch
- * @param {Array} opts.clients - SSE clients array
- * @param {Function} opts.getClaudePid - returns Claude process PID
- * @param {Function} opts.runParallelHook - plugin hook runner
- * @param {Function} opts.notifyStatsWorker - stats worker notifier
- * @param {Function} opts.getLogFile - returns current LOG_FILE value
- */
+// --- 轮转切换（抽取公共逻辑） ---
+
+async function _switchToRotatedFile(logFile, currentLogFile, clients, opts) {
+  _unwatchSingleFile(logFile);
+  const total = await countLogEntries(currentLogFile);
+  sendEventToClients(clients, 'load_start', { total, incremental: false });
+  await streamReconstructedEntriesAsync(currentLogFile, (segment) => {
+    sendChunkToClients(clients, JSON.stringify(segment));
+  });
+  sendEventToClients(clients, 'load_end', {});
+  watchLogFile({ ...opts, logFile: currentLogFile });
+}
+
+// --- 增量读 + 解析 + 广播（独立于触发机制） ---
+
+async function _readDelta(state) {
+  if (state._reading) return; // 防止并发调用（debounce + safetyTimer 可能重叠）
+  state._reading = true;
+  const { logFile, opts, reconstructor } = state;
+  const { clients, getClaudePid, runParallelHook, notifyStatsWorker, getLogFile } = opts;
+  try {
+    const st = await fsStat(logFile);
+    const currentSize = st.size;
+
+    if (currentSize < state.lastByteOffset) {
+      state.lastByteOffset = 0;
+      state.pendingTail = '';
+      reconstructor.reset();
+
+      const currentLogFile = getLogFile();
+      if (currentLogFile !== logFile && !watchedFiles.has(currentLogFile)) {
+        await _switchToRotatedFile(logFile, currentLogFile, clients, opts);
+        return;
+      }
+    }
+
+    if (currentSize <= state.lastByteOffset) return;
+
+    const bytesToRead = currentSize - state.lastByteOffset;
+    const buf = Buffer.alloc(bytesToRead);
+    const fh = await fsOpen(logFile, 'r');
+    try {
+      await fh.read(buf, 0, bytesToRead, state.lastByteOffset);
+    } finally {
+      await fh.close();
+    }
+    state.lastByteOffset = currentSize;
+
+    const raw = state.pendingTail + buf.toString('utf-8');
+    const parts = raw.split('\n---\n');
+    state.pendingTail = parts.pop() || '';
+
+    if (parts.length === 0 && state.pendingTail.trim()) {
+      try {
+        JSON.parse(state.pendingTail);
+        parts.push(state.pendingTail);
+        state.pendingTail = '';
+      } catch {}
+    }
+
+    const validParts = parts.filter(p => p.trim());
+    if (validParts.length > 0) {
+      validParts.forEach(entry => {
+        try {
+          const parsed = JSON.parse(entry);
+          if (!parsed.pid) parsed.pid = getClaudePid();
+          reconstructor.reconstruct(parsed);
+          try { enrichEntry(parsed); } catch {}
+          sendToClients(clients, parsed);
+          runParallelHook('onNewEntry', parsed).catch(() => {});
+          if (isMainAgentEntry(parsed) && !parsed.inProgress) {
+            const cached = extractCachedContent(parsed);
+            if (cached) sendEventToClients(clients, 'kv_cache_content', cached);
+            const usage = parsed.response?.body?.usage;
+            if (usage) {
+              const contextSize = getContextSizeForModel(parsed.body?.model);
+              const cwData = buildContextWindowEvent(usage, contextSize);
+              if (cwData) sendEventToClients(clients, 'context_window', cwData);
+            }
+          }
+        } catch {}
+      });
+      notifyStatsWorker(logFile);
+    }
+
+    const currentLogFile = getLogFile();
+    if (currentLogFile !== logFile && !watchedFiles.has(currentLogFile)) {
+      await _switchToRotatedFile(logFile, currentLogFile, clients, opts);
+    }
+  } catch {
+    // File not yet created or transient read error
+  } finally {
+    state._reading = false;
+  }
+}
+
+// --- 目录级 fs.watch 管理 ---
+
+function _getOrCreateDirWatcher(dir) {
+  if (_dirWatchers.has(dir)) return _dirWatchers.get(dir);
+
+  try {
+    const files = new Map();
+    const watcher = watch(dir, (eventType, filename) => {
+      if (!filename) {
+        for (const [, fileState] of files) {
+          _scheduleDebouncedRead(fileState);
+        }
+        return;
+      }
+      const fileState = files.get(filename);
+      if (fileState) _scheduleDebouncedRead(fileState);
+    });
+
+    watcher.on('error', () => {
+      for (const [, fileState] of files) {
+        _fallbackToPolling(fileState);
+      }
+      try { watcher.close(); } catch {}
+      _dirWatchers.delete(dir);
+    });
+
+    const entry = { watcher, files };
+    _dirWatchers.set(dir, entry);
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+function _scheduleDebouncedRead(fileState) {
+  if (fileState.debounceTimer) return;
+  fileState.debounceTimer = setTimeout(() => {
+    fileState.debounceTimer = null;
+    _readDelta(fileState);
+  }, FSWATCH_DEBOUNCE_MS);
+}
+
+function _fallbackToPolling(fileState) {
+  if (fileState.polling) return;
+  fileState.polling = true;
+  watchFile(fileState.logFile, { interval: 500 }, () => {
+    _readDelta(fileState);
+  });
+}
+
+function _unwatchSingleFile(logFile) {
+  const fileState = watchedFiles.get(logFile);
+  watchedFiles.delete(logFile);
+
+  if (!fileState) return;
+
+  if (fileState.debounceTimer) clearTimeout(fileState.debounceTimer);
+  if (fileState.safetyTimer) clearInterval(fileState.safetyTimer);
+
+  if (fileState.polling) {
+    try { unwatchFile(logFile); } catch {}
+    return;
+  }
+
+  const dir = dirname(logFile);
+  const filename = basename(logFile);
+  const dirEntry = _dirWatchers.get(dir);
+  if (dirEntry) {
+    dirEntry.files.delete(filename);
+    if (dirEntry.files.size === 0) {
+      try { dirEntry.watcher.close(); } catch {}
+      _dirWatchers.delete(dir);
+    }
+  }
+}
+
+// --- 公开 API ---
+
 export function watchLogFile(opts) {
-  const { logFile, clients, getClaudePid, runParallelHook, notifyStatsWorker, getLogFile } = opts;
+  const { logFile } = opts;
   if (watchedFiles.has(logFile)) return;
 
-  // Track byte offset instead of string length — avoids full-file re-read on every poll
   let lastByteOffset = 0;
-  let pendingTail = ''; // incomplete entry carried across polls
-  // Delta storage: 增量重建器，用于逐条重建 mainAgent delta 条目
   const _reconstructor = createIncrementalReconstructor();
   try {
     if (existsSync(logFile)) {
@@ -151,150 +294,60 @@ export function watchLogFile(opts) {
     }
   } catch {}
 
-  watchedFiles.set(logFile, true);
-  watchFile(logFile, { interval: 500 }, () => {
-    try {
-      const currentSize = statSync(logFile).size;
-
-      // File truncated (rotation or clear) — reset offset and check rotation immediately
-      if (currentSize < lastByteOffset) {
-        lastByteOffset = 0;
-        pendingTail = '';
-        _reconstructor.reset();
-
-        // 文件被清空可能是轮转信号，立即检查是否已切换到新文件
-        const currentLogFile = getLogFile();
-        if (currentLogFile !== logFile && !watchedFiles.has(currentLogFile)) {
-          unwatchFile(logFile);
-          watchedFiles.delete(logFile);
-
-          // 流式分段广播，避免全量加载 OOM；走 _safeSseWrite 包装做 backpressure / dead-client 清理
-          const rotTotal = countLogEntries(currentLogFile);
-          sendEventToClients(clients, 'load_start', { total: rotTotal, incremental: false });
-          streamReconstructedEntries(currentLogFile, (segment) => {
-            sendChunkToClients(clients, JSON.stringify(segment));
-          });
-          sendEventToClients(clients, 'load_end', {});
-          watchLogFile({ ...opts, logFile: currentLogFile });
-          return;
-        }
-      }
+  const fileState = {
+    logFile,
+    opts,
+    reconstructor: _reconstructor,
+    lastByteOffset,
+    pendingTail: '',
+    debounceTimer: null,
+    safetyTimer: null,
+    polling: false,
+  };
 
-      if (currentSize <= lastByteOffset) return;
+  watchedFiles.set(logFile, fileState);
 
-      // Read only the new bytes
-      const bytesToRead = currentSize - lastByteOffset;
-      const buf = Buffer.alloc(bytesToRead);
-      const fd = openSync(logFile, 'r');
-      try {
-        readSync(fd, buf, 0, bytesToRead, lastByteOffset);
-      } finally {
-        closeSync(fd);
-      }
-      lastByteOffset = currentSize;
+  if (FORCE_POLL) {
+    _fallbackToPolling(fileState);
+    return;
+  }
 
-      const raw = pendingTail + buf.toString('utf-8');
-      const parts = raw.split('\n---\n');
+  const dir = dirname(logFile);
+  const filename = basename(logFile);
+  const dirEntry = _getOrCreateDirWatcher(dir);
 
-      // Last part may be incomplete — keep it for next poll
-      pendingTail = parts.pop() || '';
+  if (!dirEntry) {
+    _fallbackToPolling(fileState);
+    return;
+  }
 
-      // If there's only the tail and no complete entries, check if tail is a complete entry
-      // (happens when the file ends without a trailing \n---\n)
-      if (parts.length === 0 && pendingTail.trim()) {
-        try {
-          JSON.parse(pendingTail);
-          // Valid JSON — treat as complete entry
-          parts.push(pendingTail);
-          pendingTail = '';
-        } catch {
-          // Incomplete — keep in pendingTail for next poll
-        }
-      }
+  dirEntry.files.set(filename, fileState);
 
-      const validParts = parts.filter(p => p.trim());
-      if (validParts.length > 0) {
-        validParts.forEach(entry => {
-          try {
-            const parsed = JSON.parse(entry);
-            if (!parsed.pid) {
-              parsed.pid = getClaudePid();
-            }
-            // Delta storage: reconstruct before push — 确保前端收到完整 messages
-            _reconstructor.reconstruct(parsed);
-            // ExitPlanMode V2 input 服务端补全（详见 enrich-plan-input.js#enrichEntry JSDoc）。
-            // 同步实现：候选扫描天然廉价（无 ExitPlanMode 块直接 0ms 返回）；命中
-            // 路径由 transcript 64MB 上限 + miss 30s TTL + path mtime 校验三层兜
-            // 住，最坏 ~150ms。如未来 hit 比例显著上升再考虑 setImmediate 拆分。
-            try { enrichEntry(parsed); } catch { /* 静默回退 */ }
-            sendToClients(clients, parsed);
-            runParallelHook('onNewEntry', parsed).catch(() => {});
-            if (isMainAgentEntry(parsed) && !parsed.inProgress) {
-              const cached = extractCachedContent(parsed);
-              if (cached) {
-                sendEventToClients(clients, 'kv_cache_content', cached);
-              }
-              const usage = parsed.response?.body?.usage;
-              if (usage) {
-                const contextSize = getContextSizeForModel(parsed.body?.model);
-                const cwData = buildContextWindowEvent(usage, contextSize);
-                if (cwData) {
-                  sendEventToClients(clients, 'context_window', cwData);
-                }
-              }
-            }
-          } catch (err) {
-            // Skip invalid entries
-          }
-        });
-        notifyStatsWorker(logFile);
-      }
+  fileState.safetyTimer = setInterval(() => {
+    _readDelta(fileState);
+  }, SAFETY_POLL_MS);
+}
 
-      // 检测日志文件是否已轮转到新文件
-      const currentLogFile = getLogFile();
-      if (currentLogFile !== logFile && !watchedFiles.has(currentLogFile)) {
-        // Unwatch old file to prevent watcher leak on rotation
-        unwatchFile(logFile);
-        watchedFiles.delete(logFile);
-
-        // 流式分段广播，避免全量加载 OOM
-        const endRotTotal = countLogEntries(currentLogFile);
-        clients.forEach(client => {
-          try { client.write(`event: load_start\ndata: ${JSON.stringify({ total: endRotTotal, incremental: false })}\n\n`); } catch { }
-        });
-        streamReconstructedEntries(currentLogFile, (segment) => {
-          const data = JSON.stringify(segment);
-          clients.forEach(client => {
-            try { client.write(`event: load_chunk\ndata: ${data}\n\n`); } catch { }
-          });
-        });
-        clients.forEach(client => {
-          try { client.write(`event: load_end\ndata: {}\n\n`); } catch { }
-        });
-        watchLogFile({ ...opts, logFile: currentLogFile });
-      }
-    } catch (err) {
-      // File not yet created, will retry on next poll
-    }
-  });
+export function unwatchLogFile(logFile) {
+  _unwatchSingleFile(logFile);
+}
+
+export function unwatchAll() {
+  for (const logFile of watchedFiles.keys()) {
+    _unwatchSingleFile(logFile);
+  }
+  for (const [, entry] of _dirWatchers) {
+    try { entry.watcher.close(); } catch {}
+  }
+  _dirWatchers.clear();
+  watchedFiles.clear();
 }
 
-/**
- * Start watching the current log file + install statusLine + context window.
- * @param {object} opts
- * @param {string} opts.logFile - current LOG_FILE
- * @param {Array} opts.clients - SSE clients array
- * @param {Function} opts.getClaudePid
- * @param {Function} opts.runParallelHook
- * @param {Function} opts.notifyStatsWorker
- * @param {Function} opts.getLogFile
- */
 export function startWatching(opts) {
   const { clients, ...watchOpts } = opts;
   watchLogFile({ ...watchOpts, clients });
 }
 
-/** Get the watchedFiles Map (for cleanup in stopViewer). */
 export function getWatchedFiles() {
   return watchedFiles;
 }

package/server/lib/plugin-manager.js

@@ -75,7 +75,7 @@ export async function installPluginFromUrl(pluginsDir, fileUrl, extractNameScrip
   writeFileSync(tmpFile, content, 'utf-8');
   try {
     const result = await new Promise((resolve, reject) => {
-      execFile('node', [extractNameScript, tmpFile], { timeout: 5000 }, (err, stdout) => {
+      execFile('node', [extractNameScript, tmpFile], { timeout: 5000, windowsHide: true }, (err, stdout) => {
         if (err) return reject(err);
         resolve(stdout);
       });