cc-viewer 1.6.348 → 1.7.1

package/server/lib/async-write-queue.js

@@ -36,8 +36,19 @@ export class AsyncWriteQueue {
   get pendingBytes() { return this._pendingBytes; }
 
   append(data, onDone) {
+    return this.appendTo(this._getPath(), data, onDone);
+  }
+
+  /**
+   * Explicit-path variant (wire-v2 S2): same queue, same ordering/drain
+   * machinery, caller supplies the target file. Within one drain batch, path
+   * groups are written in first-enqueue order, so a caller enqueuing
+   * conversation lines before the journal line keeps that relative order on
+   * disk (WIRE_FORMAT_V2.md §1.3 write-order protocol). Empty/falsy path stays
+   * a silent no-op — workspace mode and leaderless teammates rely on it.
+   */
+  appendTo(path, data, onDone) {
     if (this._closed) return;
-    const path = this._getPath();
     if (!path) {
       if (onDone) try { onDone(); } catch {}
       return;

package/server/lib/delta-reconstructor.js

@@ -88,7 +88,7 @@ function _seqGuardCheck(entry, st) {
 /**
  * 标记乱序条目并尽量就地补偿：accumulated 已包含更新的真值时，用其前缀
  * （= 截至该条目声称长度的最新内容）回填 body.messages，避免裸 delta 切片
- * 残留在请求详情面板 / mergeLogFiles 落盘产物中。
+ * 残留在请求详情面板中。
  * 返回 true 表示已补偿（messages 为一致全量），false 表示需后续 checkpoint 补偿。
  */
 function _markStaleEntry(entry, accumulated) {
@@ -142,7 +142,7 @@ function _integrityCheck(entry, accumulated, st) {
  * 2. 真值前缀 —— stale 就地补偿、超长 slice 修复（_staleReorder 置位，merge 跳过）；
  * 3. 裸 delta 切片待补偿 —— stale 就地补偿失败 / poisoned 冻结（_staleReorder 或
  *    _reconstructBroken 置位）：由第二遍 checkpoint 补偿回填，无第二遍的路径靠
- *    isMergeBlockedEntry 阻断 merge、mergeLogFiles 丢弃兜底。
+ *    isMergeBlockedEntry 阻断 merge 兜底。
  *
  * @param {object} entry - 单条日志条目（原地修改）
  * @param {{accumulated: Array, intState: {baselineSeen: boolean, poisoned: boolean},
@@ -239,7 +239,7 @@ export function reconstructEntries(entries) {
 
 /**
  * 用候选全量条目（checkpoint/旧格式，排除 teammate）补偿一条断裂条目。
- * 内容已是真值前缀，清除标记让批量 merge / mergeLogFiles 正常消费。
+ * 内容已是真值前缀，清除标记让批量 merge 正常消费。
  * @returns {boolean} true = 已补偿
  */
 function _tryRepairFromCandidate(brokenEntry, expectedCount, candidate) {

package/server/lib/error-report.js

@@ -0,0 +1,45 @@
+// CLIENT-SAFE: no node deps. Imported by src/ — do not add fs/process/node: imports.
+/**
+ * Error-reporting convention for swallowed catch blocks.
+ *
+ * Canonical home since wire-v2 S2 (moved verbatim from src/utils/errorReport.js,
+ * which remains as a re-export shell): server/lib/v2/* writers follow the same
+ * convention, and src/ is not shipped in the npm package.
+ *
+ * The rule (see CLAUDE.md): a `catch` whose failure has diagnostic value —
+ * anything where a throw means lost data or broken UI (SSE/WS event parsing,
+ * entry ingest, state updates, fetch response handling) — must call
+ * `reportSwallowed(tag, err)` instead of swallowing silently. Purely-benign
+ * best-effort guards (localStorage get/set, tabBridge IPC, revokeObjectURL,
+ * listener-cleanup `off()`) stay bare `catch {}`.
+ *
+ * Tag grammar: `<channel>.<event-name-verbatim>`, e.g. `sse.load_chunk`,
+ * `sse.stream-progress`, `ws.terminal-msg`. Keep the event name exactly as it
+ * appears in the code/protocol so a grep for the tag round-trips to the site.
+ * All reports share the greppable `[ccv:` console prefix.
+ *
+ * Dedup: identical failures usually repeat (e.g. every SSE event of a changed
+ * payload shape fails the same way), so each tag logs at most
+ * MAX_REPORTS_PER_TAG occurrences per session, then one suppression notice,
+ * then goes silent. Counter-based on purpose — no Date/timers, so this module
+ * is statically loadable and deterministic under `node --test`.
+ */
+export const MAX_REPORTS_PER_TAG = 5;
+
+const _counts = new Map();
+
+export function reportSwallowed(tag, err, extra) {
+  const n = (_counts.get(tag) || 0) + 1;
+  _counts.set(tag, n);
+  if (n > MAX_REPORTS_PER_TAG + 1) return;
+  if (n === MAX_REPORTS_PER_TAG + 1) {
+    console.warn(`[ccv:${tag}] further occurrences suppressed`);
+    return;
+  }
+  if (extra !== undefined) console.warn(`[ccv:${tag}]`, err, extra);
+  else console.warn(`[ccv:${tag}]`, err);
+}
+
+export function _resetForTest() {
+  _counts.clear();
+}

package/server/lib/im-log-watcher.js

@@ -12,7 +12,7 @@
 //    变化时触发——与 findRecentLog 的「最新真实日志」语义对齐，过滤流式临时文件噪声。
 //  - watchImpl / mkdirImpl 可注入，便于确定性单测（无需真实 FS 时序）。
 
-import { watch as fsWatch, mkdirSync, existsSync } from 'node:fs';
+import { watch as fsWatch, mkdirSync, existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 
 // fs.watch 一次文件写会抖多次（macOS/Linux 尤甚），通常 50~300ms 内合并；选 250ms 平衡实时性与稳定性。
@@ -21,14 +21,17 @@ const DEFAULT_DEBOUNCE_MS = 250;
 // 杜绝被污染的 id 经 `IM_${id}` 拼进路径造成穿越（与路由正则 /^[a-z0-9_-]+$/ 同集）。
 const PLATFORM_ID_RE = /^[a-z0-9_-]+$/;
 
-export function createImLogWatcher({ getLogDir, onChange, debounceMs = DEFAULT_DEBOUNCE_MS, watchImpl, mkdirImpl, existsImpl } = {}) {
+export function createImLogWatcher({ getLogDir, onChange, debounceMs = DEFAULT_DEBOUNCE_MS, watchImpl, mkdirImpl, existsImpl, readdirImpl } = {}) {
   const _watch = watchImpl || fsWatch;
   const _mkdir = mkdirImpl || ((d) => { try { mkdirSync(d, { recursive: true }); } catch { /* ignore */ } });
   const _exists = existsImpl || existsSync;
+  const _readdir = readdirImpl || ((d) => { try { return readdirSync(d); } catch { return []; } });
   const _onChange = typeof onChange === 'function' ? onChange : () => {};
   const _getLogDir = typeof getLogDir === 'function' ? getLogDir : () => '';
 
-  const watchers = new Map(); // platformId -> { w: FSWatcher, dir: string } —— 连同所属目录登记，便于 LOG_DIR 切换检测
+  // platformId -> { w, dir, sessionsW, sidWatchers: Map<sid, FSWatcher> }
+  // 连同所属目录登记，便于 LOG_DIR 切换检测。
+  const watchers = new Map();
   const timers = new Map();   // platformId -> timeout
   let _disposed = false;
 
@@ -51,6 +54,52 @@ export function createImLogWatcher({ getLogDir, onChange, debounceMs = DEFAULT_D
     return true;
   }
 
+  function _closeReg(reg) {
+    try { reg.w.close(); } catch { /* ignore */ }
+    if (reg.sessionsW) { try { reg.sessionsW.close(); } catch { /* ignore */ } }
+    for (const sw of reg.sidWatchers.values()) { try { sw.close(); } catch { /* ignore */ } }
+    reg.sidWatchers.clear();
+  }
+
+  // wire-v2: session appends land at IM_<id>/sessions/<sid>/journal.jsonl —
+  // two levels below the platform dir, invisible to its non-recursive watch.
+  // Per-sid watchers see journal appends (direct children of the sid dir);
+  // the sessions/-level watcher sees new sid dirs appear.
+  function _watchSid(platformId, reg, sid) {
+    if (reg.sidWatchers.has(sid)) return;
+    const sidDir = join(reg.dir, 'sessions', sid);
+    let sw;
+    try {
+      sw = _watch(sidDir, (_eventType, filename) => {
+        if (_relevant(filename)) _schedule(platformId);
+      });
+    } catch { return; }
+    if (sw && typeof sw.on === 'function') {
+      sw.on('error', () => { try { sw.close(); } catch { /* ignore */ } reg.sidWatchers.delete(sid); });
+    }
+    reg.sidWatchers.set(sid, sw);
+  }
+
+  function _ensureSessionsWatch(platformId, reg) {
+    const sessionsDir = join(reg.dir, 'sessions');
+    if (!_exists(sessionsDir)) return; // re-tried on the next platform-dir event
+    if (!reg.sessionsW) {
+      let sw;
+      try {
+        sw = _watch(sessionsDir, (_eventType, filename) => {
+          // New session dir → a fresh conversation exists; watch it and refresh.
+          if (filename) _watchSid(platformId, reg, String(filename));
+          _schedule(platformId);
+        });
+      } catch { return; }
+      if (sw && typeof sw.on === 'function') {
+        sw.on('error', () => { try { sw.close(); } catch { /* ignore */ } reg.sessionsW = null; });
+      }
+      reg.sessionsW = sw;
+    }
+    for (const sid of _readdir(sessionsDir)) _watchSid(platformId, reg, sid);
+  }
+
   function ensure(platformId) {
     if (_disposed || !platformId) return;
     if (!PLATFORM_ID_RE.test(platformId)) return; // 纵深防御：非白名单字符不放行（防 `IM_${id}` 路径穿越）
@@ -62,29 +111,40 @@ export function createImLogWatcher({ getLogDir, onChange, debounceMs = DEFAULT_D
       // 幂等仅当「目录路径未变且仍存在」时成立；否则关旧重建：
       //  - reg.dir !== dir：LOG_DIR 运行时切换（切项目），旧 watcher 还盯着旧目录，新目录无人监听；
       //  - !exists(dir)：目录被删（某些平台 fs.watch 删目录不报 error，留下永不恢复的幽灵监听）。
-      if (reg.dir === dir && _exists(dir)) return;
-      try { reg.w.close(); } catch { /* ignore */ }
+      if (reg.dir === dir && _exists(dir)) {
+        _ensureSessionsWatch(platformId, reg); // sessions/ may have appeared since
+        return;
+      }
+      _closeReg(reg);
       watchers.delete(platformId);
     }
     _mkdir(dir);
     let w;
+    const newReg = { w: null, dir, sessionsW: null, sidWatchers: new Map() };
     try {
       w = _watch(dir, (_eventType, filename) => {
+        // v2: 'sessions' appearing (or any event) is the moment to arm the
+        // deeper watchers; legacy v1 .jsonl writes keep firing directly.
+        if (String(filename || '') === 'sessions' || !filename) {
+          _ensureSessionsWatch(platformId, newReg);
+        }
         if (_relevant(filename)) _schedule(platformId);
       });
     } catch { return; }
     // watcher 出错（目录被删等）→ 关闭并撤销登记，下次 ensure 可重建。
     if (w && typeof w.on === 'function') {
-      w.on('error', () => { try { w.close(); } catch { /* ignore */ } watchers.delete(platformId); });
+      w.on('error', () => { _closeReg(newReg); watchers.delete(platformId); });
     }
-    watchers.set(platformId, { w, dir });
+    newReg.w = w;
+    watchers.set(platformId, newReg);
+    _ensureSessionsWatch(platformId, newReg);
   }
 
   function dispose() {
     _disposed = true;
     for (const t of timers.values()) clearTimeout(t);
     timers.clear();
-    for (const reg of watchers.values()) { try { reg.w.close(); } catch { /* ignore */ } }
+    for (const reg of watchers.values()) _closeReg(reg);
     watchers.clear();
   }
 

package/server/lib/interceptor-core.js

@@ -1,6 +1,5 @@
-import { appendFileSync, existsSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { renameSyncWithRetry } from './file-api.js';
-import { join, basename } from 'node:path';
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
 
 const SUBAGENT_SYSTEM_RE = /(?:command execution|file search|planning) specialist|general-purpose agent|security monitor|performing a web search/i;
 
@@ -15,7 +14,9 @@ const SUBAGENT_BILLING_RE = /cc_is_subagent=true\b/;
 // 两处服务端实现(本文件 + kv-cache-analyzer)由 test/interceptor-core-mainagent.test.js 互校防漂移；
 // 前端 contentFilter 那份由 test/content-filter-unit.test.js 单测覆盖。
 const TEAMMATE_SYSTEM_RE = /running as an agent in a team|Agent Teammate Communication/i;
-// Exported for server/lib/teammate-detect.js (previous-segment backfill filter).
+// 1.7.0: the last external consumer (teammate-detect.js) retired with the
+// prev-segment backfill; kept unexported-in-spirit for the KEEP-IN-SYNC trio
+// above (tests still cross-check the three copies).
 export { TEAMMATE_SYSTEM_RE, SUBAGENT_BILLING_RE };
 
 // Rotation carry-forward: prompt-prefix → teammate-name pairs extracted from a
@@ -40,20 +41,6 @@ export function extractAgentSpawnPairs(responseBody) {
   return pairs;
 }
 
-// Parses the first frame of a log-file head string; returns the entry when it
-// is a rotation-context sentinel, else null. Callers pass a BOUNDED head read
-// (never a whole segment).
-export function parseRotationContextHead(headString) {
-  try {
-    const frameEnd = headString.indexOf('\n---\n');
-    if (frameEnd <= 0) return null;
-    const entry = JSON.parse(headString.slice(0, frameEnd));
-    return entry && entry.ccvRotationContext ? entry : null;
-  } catch {
-    return null;
-  }
-}
-
 export function getSystemText(body) {
   const system = body?.system;
   if (typeof system === 'string') return system;
@@ -298,29 +285,27 @@ export function createStreamAssembler() {
   };
 }
 
-// 日志文件名前缀【单一来源】：writer（generateNewLogFilePath / initForWorkspace）与 matcher 共用，
-// 防止两侧命名漂移。默认 `<project>_`；`--pid` 实例 `<pid>__<project>_`。完整文件名 = `${prefix}${ts}.jsonl`。
-export function logFilePrefix(projectName, instanceId) {
-  return instanceId ? `${instanceId}__${projectName}_` : `${projectName}_`;
+// Log filename prefix (single source): v1 files were always `<project>_<ts>.jsonl`
+// (`<pid>__`-prefixed variants came from the removed multi-instance feature and
+// are excluded by the matcher below). Kept for the v1 lookups that still exist
+// (migration-era readers, e.g. findRecentLog for IM).
+export function logFilePrefix(projectName) {
+  return `${projectName}_`;
 }
 
-// 日志文件名归属判定（实例隔离）。`--pid` 实例文件名为 `<pid>__<project>_<ts>…`，无 pid 为 `<project>_<ts>…`。
-//  - instanceId 非空：必须精确以 `<pid>__<project>_` 开头（只认本实例）。
-//  - instanceId 空（默认）：以 `<project>_` 开头【且】不含 pid 分隔特征 `__<project>_`。后一条堵住前缀碰撞——
-//    若用户把 --pid 取成项目名或 `<项目>_…`（如项目 proj 用 --pid=proj → `proj__proj_…` 也会 startsWith `proj_`），
-//    仅靠前缀无法排除；而任何 pid 文件按构造必含 `__<project>_`，无标签文件绝不含（即便项目名自身带 `__`），据此精确排除。
-export function logFileMatcher(projectName, instanceId) {
-  const p = logFilePrefix(projectName, instanceId);
-  if (instanceId) return (f) => f.startsWith(p);
+// v1 log filename ownership test: starts with `<project>_` and does NOT carry
+// the legacy `<pid>__<project>_` instance mark (any instance-tagged file
+// contains `__<project>_` by construction; untagged files never do, even when
+// the project name itself contains `__`).
+export function logFileMatcher(projectName) {
+  const p = logFilePrefix(projectName);
   const pidMark = `__${projectName}_`;
   return (f) => f.startsWith(p) && !f.includes(pidMark);
 }
 
-// instanceId 为可选第 3 参（默认 null = 现状）：非空时只在本实例自己的日志里找（多进程隔离），
-// 现有 2 参调用方与单测零改动。
-export function findRecentLog(dir, projectName, instanceId = null) {
+export function findRecentLog(dir, projectName) {
   try {
-    const owns = logFileMatcher(projectName, instanceId);
+    const owns = logFileMatcher(projectName);
     const files = readdirSync(dir)
       // 排除 *_temp.jsonl：临时文件是未完成的写入态（resume 流程中途产物），
       // 不应被当作"最近完整日志"（否则 _temp 因 sort 排在正式文件之后会被误选）。
@@ -333,114 +318,6 @@ export function findRecentLog(dir, projectName, instanceId = null) {
   return null;
 }
 
-// 首启接管（仅 --pid 实例）：本 pid 还没有自己的日志时，把项目里最近的【无标签】日志原子 rename 成
-// `<pid>__<project>_<ts>.jsonl`，并入该 pid 血脉（move 而非 copy：不双计入统计）。返回接管后的新路径，或 null。
-//
-// 这是 best-effort 便利特性，不是核心隔离（核心隔离=各 pid 读自己的日志，不依赖接管）。为不误抢一个仍存活的
-// 无 pid 实例（评审标记的 live-writer / 卡在 resume 的窄边角），双重守卫：① 项目里若存在任何无标签 `*_temp.jsonl`
-// （某个无 pid 实例正卡在 resume / 在写）→ 放弃；② 无标签日志 mtime 必须早于 freshnessMs(默认 5min)。仍有理论窄缝
-// （进程挂起 >5min 且无 temp），属可接受的便利取舍。并发下原子 rename 只一个赢、输者 throw→吞→null（回退全新）。
-export function claimUntaggedLog(dir, projectName, instanceId, { freshnessMs = 300000 } = {}) {
-  if (!instanceId) return null;
-  try {
-    const untagged = findRecentLog(dir, projectName, null); // 最近无标签日志（已排除 pid 文件 + temp）
-    if (!untagged) return null;
-    // ① 存在无标签 temp ⇒ 有无 pid 实例正活动/卡在 resume → 不接管。
-    const owns = logFileMatcher(projectName, null);
-    const hasUntaggedTemp = readdirSync(dir).some(f => owns(f) && f.endsWith('_temp.jsonl'));
-    if (hasUntaggedTemp) return null;
-    let st;
-    try { st = statSync(untagged); } catch { return null; }
-    if (Date.now() - st.mtimeMs < freshnessMs) return null; // ② 可能是活动写者 → 不碰
-    const claimed = join(dir, `${instanceId}__${basename(untagged)}`);
-    if (existsSync(claimed)) return null;                   // 极端撞名 → 放弃
-    renameSyncWithRetry(untagged, claimed);
-    return claimed;
-  } catch { return null; }
-}
-
-export function cleanupTempFiles(dir, projectName, instanceId = null) {
-  try {
-    const owns = logFileMatcher(projectName, instanceId);
-    const tempFiles = readdirSync(dir)
-      .filter(f => owns(f) && f.endsWith('_temp.jsonl'));
-    for (const f of tempFiles) {
-      try {
-        const tempPath = join(dir, f);
-        const newPath = tempPath.replace('_temp.jsonl', '.jsonl');
-        if (existsSync(newPath)) {
-          const tempContent = readFileSync(tempPath, 'utf-8');
-          if (tempContent.trim()) {
-            appendFileSync(newPath, tempContent);
-          }
-          unlinkSync(tempPath);
-        } else {
-          // 只有非空 temp 文件才 rename，空文件直接删除
-          const sz = statSync(tempPath).size;
-          if (sz > 0) {
-            renameSyncWithRetry(tempPath, newPath);
-          } else {
-            unlinkSync(tempPath);
-          }
-        }
-      } catch { }
-    }
-  } catch { }
-}
-
-export function migrateConversationContext(oldFile, newFile) {
-  try {
-    const content = readFileSync(oldFile, 'utf-8');
-    if (!content.trim()) return;
-
-    const parts = content.split('\n---\n').filter(p => p.trim());
-    if (parts.length === 0) return;
-
-    let originIndex = -1;
-    for (let i = parts.length - 1; i >= 0; i--) {
-      if (!/"mainAgent"\s*:\s*true/.test(parts[i])) continue;
-      try {
-        const entry = JSON.parse(parts[i]);
-        if (entry.mainAgent) {
-          const msgs = entry.body?.messages;
-          // Delta storage: 使用 _totalMessageCount（delta 条目）或 msgs.length（旧格式）
-          const msgCount = entry._totalMessageCount || (Array.isArray(msgs) ? msgs.length : 0);
-          if (msgCount === 1) {
-            originIndex = i;
-            break;
-          }
-        }
-      } catch { }
-    }
-
-    if (originIndex < 0) return;
-
-    let migrationStart = originIndex;
-    if (originIndex > 0) {
-      try {
-        const prevContent = parts[originIndex - 1];
-        if (prevContent.trim().startsWith('{')) {
-          const prev = JSON.parse(prevContent);
-          if (isPreflightEntry(prev)) {
-            migrationStart = originIndex - 1;
-          }
-        }
-      } catch { }
-    }
-
-    const migratedParts = parts.slice(migrationStart);
-    writeFileSync(newFile, migratedParts.join('\n---\n') + '\n---\n');
-
-    const remainingParts = parts.slice(0, migrationStart);
-    if (remainingParts.length > 0) {
-      writeFileSync(oldFile, remainingParts.join('\n---\n') + '\n---\n');
-    } else {
-      // 所有内容已迁移到新文件，清空旧文件（不能删除，watcher 需要检测 truncation 来触发轮转）
-      writeFileSync(oldFile, '');
-    }
-  } catch { }
-}
-
 /**
  * 计算单条 message 的轻量身份指纹，用于 delta storage 的 in-place last-msg replace 检测。
  * 仅服务端 interceptor 使用 —— 触发 Plan C checkpoint 让客户端拿到 wire 真实内容。
@@ -479,38 +356,6 @@ export function fingerprintMsg(m) {
   return (m.role || '?') + ':' + snip.replace(/\s+/g, ' ').slice(0, 80);
 }
 
-/**
- * Rotate log file when it exceeds maxSize.
- * Creates a new file (no content migration) and appends '\n' to old file
- * to trigger fs.watchFile callback for watcher migration.
- *
- * initialContent (optional) is written INTO the new file at creation time —
- * used for the rotation-context sentinel. It must be baked into creation
- * rather than queued afterwards: the old-file trigger byte below fires the
- * watcher's rotation-follow after a short debounce, and a late-flushing
- * queued write can land between the new file's initial stream read and its
- * lastByteOffset snapshot, in which case it is never delivered to clients.
- *
- * @param {string} currentFile - current log file path
- * @param {string} newFile - new log file path to rotate to
- * @param {number} maxSize - max file size in bytes
- * @param {string} [initialContent] - content the new file is created with
- * @returns {{ rotated: boolean, oldFile?: string, newFile?: string }}
- */
-export function rotateLogFile(currentFile, newFile, maxSize, initialContent = '') {
-  try {
-    if (!existsSync(currentFile)) return { rotated: false };
-    const size = statSync(currentFile).size;
-    if (size < maxSize) return { rotated: false };
-    // 不迁移旧内容，创建新文件（立即创建，避免 watcher 时序窗口）
-    try { writeFileSync(newFile, initialContent); } catch { }
-    // 触发旧文件 watcher 回调，使其检测到文件变更并切换到新文件
-    try { appendFileSync(currentFile, '\n'); } catch { }
-    return { rotated: true, oldFile: currentFile, newFile };
-  } catch { }
-  return { rotated: false };
-}
-
 /**
  * 在原始 JSON 字符串上定向替换顶层 "model" 字段的值，避免对巨型 wire body
  * （`-c` 重启后的全量 checkpoint 请求可达数十 MB）做二次 JSON.parse + 全量 re-stringify。