cc-viewer 1.7.0 → 1.7.1

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-Ac8vnV3v.js"></script>
+  <script type="module" crossorigin src="./assets/index-B51Ci0GL.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-DI7JL-mE.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-B9c49dtM.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-B6cpBtIE.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",
@@ -66,6 +66,7 @@
     "findcc.js",
     "interceptor.js",
     "server/",
+    "src/utils/",
     "plugins/",
     "concepts/",
     "ultraAgents/"

package/server/lib/log-watcher.js

@@ -4,6 +4,7 @@ import { buildContextWindowEvent, getContextSizeForModel } from './context-watch
 import { reconstructEntries } from './delta-reconstructor.js';
 import { enrichEntry } from './enrich-plan-input.js';
 import { enrichEntry as enrichWorkflowEntry } from './enrich-workflow.js';
+import { sseWrite } from './wire-compress.js';
 
 // 1.7.0: the v1 log-file tail (fs.watch + byte cursors + rotation follow)
 // retired with the v1 write path — the live channel is server/lib/v2/
@@ -60,7 +61,11 @@ function _safeSseWrite(clients, client, payload) {
   }
   let ok;
   try {
-    ok = client.write(payload);
+    // sseWrite routes through the client's negotiated Content-Encoding
+    // (wire-compress.js) — a bare client.write here would corrupt compressed
+    // streams. The drain listener below stays on the res: the encoder is
+    // piped into it, so socket drain still propagates.
+    ok = sseWrite(client, payload);
   } catch {
     _removeClient(clients, client);
     return false;
@@ -68,9 +73,18 @@ function _safeSseWrite(clients, client, payload) {
   if (!ok) {
     if (!client._sseBackpressureSince) {
       client._sseBackpressureSince = Date.now();
-      client.once('drain', () => { client._sseBackpressureSince = 0; });
+      // On compressed clients the false write() came from the ENCODER (its
+      // input buffer), whose own 'drain' fires when compression catches up —
+      // the res may never emit 'drain' at all (compressed output is 20-80x
+      // smaller than what the socket can absorb). Arming the reset on the
+      // wrong stream would let the timeout below kill healthy clients.
+      const pressured = client._wireEnc || client;
+      pressured.once('drain', () => { client._sseBackpressureSince = 0; });
     } else if (Date.now() - client._sseBackpressureSince > SSE_BACKPRESSURE_TIMEOUT_MS) {
       _removeClient(clients, client);
+      // Destroy the encoder first: end() alone leaves the 16MB brotli window
+      // alive until TCP teardown of the already-stuck socket.
+      try { if (client._wireEnc) client._wireEnc.destroy(); } catch {}
       try { client.end(); } catch {}
       return false;
     }
@@ -92,6 +106,15 @@ export function sendEventToClients(clients, eventName, data) {
   }
 }
 
+/** Like sendEventToClients but `json` is an ALREADY-serialized JSON string —
+ *  wire v3 forwards raw stored lines verbatim without a parse/stringify trip. */
+export function sendEventRawToClients(clients, eventName, json) {
+  const payload = `event: ${eventName}\ndata: ${json}\n\n`;
+  for (let i = clients.length - 1; i >= 0; i--) {
+    _safeSseWrite(clients, clients[i], payload);
+  }
+}
+
 export function sendChunkToClients(clients, dataJson) {
   const payload = `event: load_chunk\ndata: ${dataJson}\n\n`;
   for (let i = clients.length - 1; i >= 0; i--) {
@@ -115,7 +138,10 @@ export function processWatchedEntry(parsed, ctx) {
   reconstructor.reconstruct(parsed);
   try { enrichEntry(parsed); } catch {}
   try { enrichWorkflowEntry(parsed); } catch {}
-  sendToClients(clients, parsed);
+  // Wire v3 (V3.S5): the flagged v2 live feed suppresses the full-entry
+  // broadcast — clients rebuild entries from native lines + rows. The kv/
+  // context side events below still fire (they are slim and file-agnostic).
+  if (!ctx.suppressEntryBroadcast) sendToClients(clients, parsed);
   runParallelHook('onNewEntry', parsed).catch(() => {});
   if (isMainAgentEntry(parsed) && !parsed.inProgress) {
     const cached = extractCachedContent(parsed);

package/server/lib/v2/adapter.js

@@ -402,12 +402,30 @@ export class SessionSynthesizer {
     // ---- body (blob backfill is per-request by journal ref — never carried) --
     const tools = this._loadBlob(req.blobs && req.blobs.tools);
     const system = this._loadBlob(req.blobs && req.blobs.sys);
+    // req.params carries every residual body field (params-era journals);
+    // dedicated fields override it so precedence is deterministic. user_id is
+    // ALWAYS meta.userIdRaw — the client does equality-based session-boundary
+    // detection on it, and a `-c` adopted folder mixes real user_ids that
+    // would otherwise split the timeline mid-session.
+    const params = req.params && typeof req.params === 'object' ? req.params : null;
     const body = {
+      ...params,
       ...(req.model && { model: req.model }),
       ...(system !== undefined && { system }),
       ...(tools !== undefined && { tools }),
-      ...(meta.userIdRaw && { metadata: { user_id: meta.userIdRaw } }),
     };
+    if (meta.userIdRaw) {
+      const extra = body.metadata && typeof body.metadata === 'object' ? body.metadata : null;
+      body.metadata = { ...extra, user_id: meta.userIdRaw };
+    } else if (body.metadata && typeof body.metadata === 'object' && body.metadata.user_id !== undefined) {
+      // noid session (no parseable user_id at write time): a raw params
+      // user_id may vary per request, and surfacing it would re-open the
+      // spurious client boundary-split this block exists to prevent. Drop
+      // ONLY user_id; other metadata keys keep full fidelity.
+      const { user_id, ...restMeta } = body.metadata;
+      if (Object.keys(restMeta).length > 0) body.metadata = restMeta;
+      else delete body.metadata;
+    }
 
     const isTeammateEntry = isTeammate;
     const isMainKind = isMain;
@@ -523,6 +541,7 @@ export class SessionSynthesizer {
     }
     entry.response = {
       ...(typeof done.http === 'number' && { status: done.http }),
+      ...(resp && resp.statusText && { statusText: resp.statusText }),
       ...(resp && resp.headers && { headers: resp.headers }),
       body: resp ? resp.body : null,
     };
@@ -646,7 +665,7 @@ export function findTeammateSessionDirs(sessionDir, leaderUuid) {
  * Item-level iteration of one v2 session with teammate re-join — the shared
  * core of the raw-string generators and the window reader below.
  */
-function* iterateV2Items(sessionDir, opts = {}) {
+export function* iterateV2Items(sessionDir, opts = {}) {
   const streams = [iterateSessionItems(sessionDir, opts)];
   const ownMeta = (() => {
     try { return JSON.parse(readFileSync(join(sessionDir, 'meta.json'), 'utf-8')); } catch { return null; }
@@ -735,7 +754,7 @@ export function _v2WindowStatsForTest(reset = false) {
  * The result is IMMUTABLE and shared across coalesced callers — window
  * selection must not mutate `recs`/`ring`.
  */
-async function scanV2Descriptors(sessionDir) {
+export async function scanV2Descriptors(sessionDir) {
   _windowStats.scanRuns++;
   const dedup = new Map(); // key → descriptor (insertion order = output order)
   const ring = []; // newest ≤3 isMain descriptors, pre-dedup iteration order
@@ -796,7 +815,7 @@ function selectV2Window(scan, opts = {}) {
 
 /** Level-1 shared Pass A + per-caller selection. `cached` gates the TTL
  *  micro-cache read (F5b: /events live-attach must never consume it). */
-async function computeV2Window(sessionDir, opts = {}) {
+export async function computeV2Window(sessionDir, opts = {}) {
   const scan = await _scanFlight.run(`scan:${sessionDir}`, () => scanV2Descriptors(sessionDir), { cached: !!opts.cached });
   return selectV2Window(scan, opts);
 }
@@ -813,7 +832,7 @@ async function computeV2Window(sessionDir, opts = {}) {
  * equivalent (algorithm review F6). `collect` mode fills a slot array in
  * Pass A output order instead: byte-identical to the historical single pass.
  */
-async function materializeV2Window(sessionDir, win, { collect = false, onEntry = null } = {}) {
+async function materializeV2Window(sessionDir, win, { collect = false, onEntry = null, promoteKeys = null } = {}) {
   const memberIdx = new Map();
   win.members.forEach((d, i) => memberIdx.set(itemKey(d.sessionId, d.seq), i));
   const ringKeys = new Set(win.ring.map((d) => itemKey(d.sessionId, d.seq)));
@@ -837,7 +856,12 @@ async function materializeV2Window(sessionDir, win, { collect = false, onEntry =
       // replayed state (item.stateRef aliases the live conversation state at
       // this seq — used transiently, never retained). Same construction as the
       // historical end-of-window rebuild, byte-for-byte.
-      if (k === win.baselineKey) {
+      // `promoteKeys` (V3.S1): per-member force-checkpoint for single-entry
+      // reads — a mid-session main delta carries only its appended slice, but
+      // the detail view needs the full replayed state for BOTH the target and
+      // its prevMain (Body Diff / cacheLoss compare whole messages arrays).
+      // The window baseline promotes only win.baselineKey (the window start).
+      if (k === win.baselineKey || (promoteKeys && promoteKeys.has(k))) {
         const state = item.stateRef || [];
         const rebuilt = { ...item.entry, body: { ...item.entry.body, messages: state } };
         rebuilt._isCheckpoint = true;
@@ -889,6 +913,47 @@ async function materializeV2Window(sessionDir, win, { collect = false, onEntry =
  * @param {{limit?: number, before?: string|null, cached?: boolean}} [opts]
  * @returns {Promise<{entries: string[], hasMore: boolean, oldestTimestamp: string, totalCount: number, mainAgentRing: string[]}>}
  */
+/**
+ * V3.S1: on-demand single-entry read — the detail view's data source once the
+ * request list is metadata rows. Locates the target (sessionId, seq) in the
+ * shared descriptor scan, pairs it with its preceding isMain descriptor
+ * (Body Diff / Context tab need the previous mainAgent, raw-seq adjacency),
+ * and materializes exactly those members with per-member checkpoint promotion
+ * (main deltas come back with the full replayed state, matching what the
+ * client holds after reconstruction on the legacy channel).
+ *
+ * @param {string} sessionDir - leader session dir (teammate rows resolve
+ *   through the leader's k-way fold so tags/order match the list)
+ * @param {{seq: number, sessionId?: string|null, cached?: boolean}} opts -
+ *   sessionId (UUID) disambiguates teammate rows; null = any session's seq
+ * @returns {Promise<{entry: string, prevMain: string|null}|null>} raw JSON
+ *   strings (never re-parsed here), or null when the seq is unknown / gated
+ *   out by synthesis (crash-orphan) — callers answer 404.
+ */
+export async function readV2SingleEntry(sessionDir, opts = {}) {
+  const seq = opts.seq;
+  const sessionId = opts.sessionId || null;
+  const key = `entry:${sessionDir}|${sessionId || ''}|${seq}`;
+  return _windowFlight.run(key, async () => {
+    const scan = await _scanFlight.run(`scan:${sessionDir}`, () => scanV2Descriptors(sessionDir), { cached: true });
+    const recs = scan.recs;
+    const idx = recs.findIndex((d) => d.seq === seq && (!sessionId || d.sessionId === sessionId));
+    if (idx === -1) return null;
+    const target = recs[idx];
+    let prevMain = null;
+    for (let i = idx - 1; i >= 0; i--) {
+      if (recs[i].isMain) { prevMain = recs[i]; break; }
+    }
+    const members = prevMain ? [prevMain, target] : [target];
+    const win = { members, ring: [], baselineKey: null };
+    const promoteKeys = new Set(members.filter((d) => d.isMainDelta).map((d) => itemKey(d.sessionId, d.seq)));
+    const { slots } = await materializeV2Window(sessionDir, win, { collect: true, promoteKeys });
+    const entry = slots[members.length - 1];
+    if (entry === undefined) return null; // synthesis gate dropped it between passes
+    return { entry, prevMain: prevMain ? (slots[0] ?? null) : null };
+  }, { cached: opts.cached !== false });
+}
+
 export async function readV2WindowedEntries(sessionDir, opts = {}) {
   const cached = !!opts.cached;
   const key = `win:${sessionDir}|${opts.limit || 0}|${opts.before || ''}`;

package/server/lib/v2/live-feed.js

@@ -26,8 +26,10 @@ import { watch, existsSync, readdirSync, statSync, openSync, readSync, closeSync
 import { join } from 'node:path';
 import { reportSwallowed } from '../error-report.js';
 import { createIncrementalReconstructor } from '../delta-reconstructor.js';
-import { processWatchedEntry } from '../log-watcher.js';
+import { processWatchedEntry, sendEventToClients, sendEventRawToClients } from '../log-watcher.js';
 import { SessionSynthesizer } from './adapter.js';
+import { computeCacheLoss } from './meta-rows.js';
+import { classifyRequest } from '../../../src/utils/requestType.js';
 
 const FSWATCH_DEBOUNCE_MS = 80;
 const SAFETY_POLL_MS = 5000;
@@ -91,6 +93,10 @@ export class V2LiveFeed {
     this._safetyPollMs = typeof opts.safetyPollMs === 'number' ? opts.safetyPollMs : SAFETY_POLL_MS;
     this._deferMs = typeof opts.deferMs === 'number' ? opts.deferMs : DEFER_MS;
     this._now = opts.now || Date.now;
+    // Wire v3 (V3.S2): when on, every emitted item ALSO broadcasts a metadata
+    // row (v2_requests_delta). Explicit ctor param — this module has no access
+    // to the server deps object.
+    this._wireV3 = !!opts.wireV3;
     this._sessions = new Map(); // dir → cursor bundle
     this._seenDirs = new Map(); // dir → last observed journal mtimeMs (attached or not)
     this._sessionsRoot = null;
@@ -299,7 +305,13 @@ export class V2LiveFeed {
         this._feedConvFiles(cur);
         const respLines = readNewLines(cur.responses);
         if (respLines === null) { this._rebuildCursor(cur); return; }
-        for (const raw of respLines) cur.synth.ingestResponseLine(raw);
+        for (const raw of respLines) {
+          cur.synth.ingestResponseLine(raw);
+          // Wire v3 (V3.S4): forward the raw stored line — the flagged client
+          // assembles v1-shape entries from native lines locally. Suppressed
+          // during seed (history is covered by the cold-load channel).
+          if (this._wireV3 && !cur.suppress) this._forwardNative(cur, 'resp', null, raw);
+        }
         const journalLines = readNewLines(cur.journal);
         if (journalLines === null) { this._rebuildCursor(cur); return; }
         for (const raw of journalLines) {
@@ -351,7 +363,10 @@ export class V2LiveFeed {
           try { ev = JSON.parse(raw); } catch (err) {
             reportSwallowed('v2-live.conv-parse', new Error(`${cur.dir}/${key}: ${err.message}`));
           }
-          if (ev) cur.synth.ingestConvLine(key, ev);
+          if (ev) {
+            cur.synth.ingestConvLine(key, ev);
+            if (this._wireV3 && !cur.suppress) this._forwardNative(cur, 'conv', key, raw);
+          }
         }
       }
     }
@@ -403,17 +418,109 @@ export class V2LiveFeed {
           clients: this._clients,
           getClaudePid: this._getClaudePid,
           runParallelHook: this._runParallelHook,
+          suppressEntryBroadcast: this._wireV3,
         });
         emitted++;
       } catch (err) {
         reportSwallowed('v2-live.emit', err);
       }
+      // Wire v3: derive the metadata row from the post-reconstruction entry
+      // (main deltas carry full messages here — classification/cacheLoss get
+      // the same inputs the legacy list sees). Row-level errors must not
+      // disturb the legacy broadcast above.
+      if (this._wireV3) {
+        try {
+          this._emitRow(cur, item, parsed);
+        } catch (err) {
+          reportSwallowed('v2-live.row', err);
+        }
+      }
     }
     if (emitted > 0 && this._notifyStatsWorker) {
       try { this._notifyStatsWorker(cur.dir); } catch (err) { reportSwallowed('v2-live.stats-notify', err); }
     }
   }
 
+  /** Wire v3 (V3.S4): broadcast one raw native line (conv event or responses
+   *  line) — the flagged client's assembler replays these into v1-shape
+   *  entries. `raw` is forwarded verbatim inside a JSON envelope carrying the
+   *  session identity + channel. sessionId comes from the synthesizer (the
+   *  UUID, matching the rows' sessionId and the entries' _seqEpoch). */
+  _forwardNative(cur, kind, channel, raw) {
+    try {
+      const payload = kind === 'conv'
+        ? `{"sessionId":${JSON.stringify(cur.synth.sessionId)},"channel":${JSON.stringify(channel)},"line":${raw}}`
+        : `{"sessionId":${JSON.stringify(cur.synth.sessionId)},"line":${raw}}`;
+      const eventName = kind === 'conv' ? 'v3_conv' : 'v3_resp';
+      sendEventRawToClients(this._clients, eventName, payload);
+    } catch (err) {
+      reportSwallowed('v2-live.native-forward', err);
+    }
+  }
+
+  /** Wire v3 (V3.S2): one metadata row per emitted item, derived from the
+   *  post-reconstruction entry. Rows upsert client-side by (sessionId, seq):
+   *  a placeholder row precedes its completed row, and a correction re-send
+   *  follows when the NEXT request's arrival changes the previous row's
+   *  classification (classifyRequest's Preflight/Plan cases read nextReq). */
+  _rowFrom(item, parsed) {
+    const usage = parsed.response?.body?.usage || null;
+    return {
+      seq: item.seq,
+      sessionId: item.sessionId,
+      timestamp: parsed.timestamp || '',
+      url: parsed.url || '',
+      method: parsed.method || 'POST',
+      kind: item.isMain ? 'main' : (parsed.teammate ? 'teammate' : 'sub'),
+      mainAgent: parsed.mainAgent === true,
+      teammate: parsed.teammate || undefined,
+      model: parsed.body?.model,
+      proxyUrl: parsed.proxyUrl || undefined,
+      status: parsed.response?.status,
+      duration: parsed.duration,
+      usage: usage ? {
+        input_tokens: usage.input_tokens || 0,
+        output_tokens: usage.output_tokens || 0,
+        cache_read_input_tokens: usage.cache_read_input_tokens || 0,
+        cache_creation_input_tokens: usage.cache_creation_input_tokens || 0,
+      } : null,
+      inProgress: !!parsed.inProgress,
+      typeTag: null,
+      cacheLoss: null,
+    };
+  }
+
+  _emitRow(cur, item, parsed) {
+    const row = this._rowFrom(item, parsed);
+    try {
+      const tag = classifyRequest(parsed, null);
+      row.typeTag = tag ? { type: tag.type, subType: tag.subType ?? null } : null;
+    } catch (err) { reportSwallowed('v2-live.row-classify', err); }
+    if (row.mainAgent && !row.inProgress) {
+      const u = parsed.response?.body?.usage;
+      const cw = (u && u.cache_creation_input_tokens) || 0;
+      const cr = (u && u.cache_read_input_tokens) || 0;
+      if (cur._v3PrevMain && cw > 0 && cw > cr) {
+        try { row.cacheLoss = computeCacheLoss(cur._v3PrevMain, parsed); } catch (err) { reportSwallowed('v2-live.row-cacheloss', err); }
+      }
+      cur._v3PrevMain = parsed; // one full entry retained per cursor (bounded)
+    }
+    // Lookahead correction: this entry is the previous row's nextReq.
+    const prev = cur._v3Last;
+    if (prev && (prev.row.sessionId !== row.sessionId || prev.row.seq !== row.seq)) {
+      try {
+        const tag = classifyRequest(prev.entry, parsed);
+        const corrected = tag ? { type: tag.type, subType: tag.subType ?? null } : null;
+        if (JSON.stringify(corrected) !== JSON.stringify(prev.row.typeTag)) {
+          prev.row.typeTag = corrected;
+          sendEventToClients(this._clients, 'v2_requests_delta', prev.row);
+        }
+      } catch (err) { reportSwallowed('v2-live.row-classify', err); }
+    }
+    cur._v3Last = { row, entry: parsed };
+    sendEventToClients(this._clients, 'v2_requests_delta', row);
+  }
+
   // ── safety poll ────────────────────────────────────────────────────────────
 
   _safetyTick() {