feat(log-list): perf cache + server-side pagination + project switcher (1.7.13)

Session log list performance and UX overhaul for the log-management modal:

- perf: session row cache (server/lib/v2/session-list.js) keyed by
  journal+prompts size+mtime; repeat /api/local-logs calls drop from a full
  rescan to O(N statSync). migrationStatus gains a 10s TTL memo, invalidated
  on convert-worker completion.
- feat: server-side pagination — GET /api/local-logs?page=&pageSize= returns
  {items,total,page,pageSize} for one project, summarizing only the requested
  page (rest ride the row cache); the modal table is a controlled 50/page
  server-paginated grid. No params = legacy grouped shape (backward compatible).
- feat: project switcher — ?project= serves any project's v2 sessions (strict
  sanitizePathComponent compare rejects traversal); response carries
  _allProjects for the toolbar dropdown. currentProject (active) stays separate
  from logViewProject (viewed); viewing a non-active project disables the v1
  migration button and hides the banner; switching clears the selection.
- ui: fixed-height modal content box + pinned pager (no bounce on load);
  mobile list scrolls vertically so deeper pages stay reachable.
- fix: _currentProject always reports the active project (_viewedProject
  reports the listed one) so viewing a project can't pollute global state;
  fetch failures reset localLogsLoading; _allProjects skips dot-dirs.

i18n: ui.logsTotal / ui.selectProject / ui.migrateCurrentProjectOnly (18 langs).
Tests: v2-session-list (row cache + listV2LogsPage incl. post-filter paging),
api-logs-gap (?project= incl. traversal/clamps/fallback), TTL memo + hook.

Author: weiesky.wangc

history.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.7.13 (2026-08-01)
+
+- perf(log-list): **session list row cache** — `GET /api/local-logs` re-scanned every session on every call (full journal fold + recursive dir walk + 256KB prompts head read per session, all sync). With 100+ sessions this blocked the event loop for seconds. New `server/lib/v2/session-list.js` caches per-session rows keyed by journal+prompts size+mtime; repeat calls drop to O(N statSync + 1 readdir) ≈ 1-3ms. All existing gates (wireFormat, sentinel, discard, error→keep) preserved verbatim. Cross-review hardening (2026-07-31): freshness key spans prompts.jsonl (written after the journal line / backfilled on crash-resume), O(N²) prune → Set, delivered rows re-copy nested preview/leader so callers can't poison the cache.
+- perf(log-list): **migrationStatus 10s TTL memo** — `migrationStatus` was called on every SSE connect, every list refresh, and every workspace boot, each time stat-scanning all v1 files of all projects. A per-(logDir, project) 10s TTL memo collapses repeat calls to a Map lookup; the convert manager invalidates on worker completion so a finished conversion is reflected immediately.
+- test(log-list): **TTL memo + invalidation hook behavior coverage** — injectable clock drives the 10s window (serve within TTL / recompute after expiry / per-project `_invalidate`); the convert-manager test pre-fills a stale memo verdict and asserts the worker's `final` message drops it so the next call re-scans. Removed a tautological key-collision test; the stale/recompute contract is pinned observably instead (meta change invisible to the cache until the next journal append; prompts append alone triggers recompute).
+- feat(log-list): **server-side pagination for the log modal** — `GET /api/local-logs?page=&pageSize=` returns `{items, total, page, pageSize}` for the current project, summarizing only the requested page's sessions (rest ride the row cache). New `listV2LogsPage` (log-management) + `summarizeSessionPage` (session-list); the modal's v2 table is now a controlled server-paginated grid (50/page) instead of one unpaged fetch. Selection (`selectedLogs`) is unchanged — a cross-page Set feeding the existing per-file delete whitelist. No params = legacy grouped shape (backward compatible); v1 view untouched.
+- feat(log-list): **project switcher in the log modal** — the modal toolbar gains a project dropdown to view other projects' v2 session logs without switching the active workspace. `GET /api/local-logs?page=&project=` serves any project (strict `sanitizePathComponent` compare rejects `..`/separators → 400); the response carries `_allProjects` for the dropdown. Frontend keeps two project concepts separate: `currentProject` (active, drives migration counts/banner) vs new `logViewProject` (viewed); viewing a non-active project disables the v1-migration button + hides the unmigrated banner, and switching clears the selection. Alias-aware labels (`alias (dir)`). Desktop only.
+- ui(log-list): **fixed-height modal content + pinned pager** — the v2 table's content box is a fixed height (desktop `min(600px, 100vh-280px)`) so swapping the table for a spinner no longer bounces the modal; antd `scroll.y` keeps the header sticky and pins the pager to the box bottom; `hideOnSinglePage` hides the pager when only one page exists.
+
 ## 1.7.12 (2026-07-30)
 
 - ui(avatar): **refresh the Kimi model logo** — new mark with the brand-blue dot kept fixed (`#1783FF`) and the "K" glyph switched to `currentColor` so it follows `--model-logo-mono` (white in dark mode, black in light mode), matching the GLM/MiniMax mono-logo theming.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.7.12",
+  "version": "1.7.13",
   "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",

server/lib/log-management.js

@@ -4,6 +4,8 @@ import { join, sep, dirname, basename } from 'node:path';
 import { reconstructEntries } from './delta-reconstructor.js';
 import { sanitizePathComponent } from './v2/layout.js';
 import { listV2Sessions } from './v2/adapter.js';
+import { summarizeSessionPage } from './v2/session-list.js';
+import { listSessionIds } from './v2/replay.js';
 
 // wire-v2 S5 addressing (spec §12): 'v2:<project>/<session_id>' in every
 // existing ?file= parameter slot. Components must survive the same whitelist
@@ -122,6 +124,61 @@ export function listV2Logs(logDir, currentProjectName) {
   return { ...grouped, _currentProject: currentProjectName || '' };
 }
 
+/**
+ * Server-side paginated v2 log list for ONE project (2026-07-31). The modal
+ * only ever renders the current project's sessions, so instead of summarizing
+ * every session up front we page: enumerate session dirs (readdir — cheap),
+ * read each meta.json only for the startTs ordering + leader filter, sort
+ * newest-first, then run the EXPENSIVE summarize (journal fold + dir walk +
+ * prompts head) on just the `pageSize` sessions of the requested page — those
+ * go through the same row cache as listV2Sessions, so revisiting a page is
+ * ~1-3ms. Trade-off documented inline: `size==0` and `discard` verdicts live
+ * behind that summarize, so `total` is the pre-filter session count (the empty
+ * / quota-probe sessions are excluded as their pages are computed). For
+ * realistic data (empties + probes are a small minority) this keeps cold open
+ * at ~1 page of work instead of N.
+ *
+ * @returns {{items: Array, total: number, page: number, pageSize: number}}
+ *   items rows keep the exact listV2Logs shape {file, kind, timestamp, size, turns, preview}.
+ */
+export function listV2LogsPage(logDir, project, { page = 1, pageSize = 50 } = {}) {
+  const out = { items: [], total: 0, page, pageSize, _currentProject: project || '' };
+  if (!project) return out;
+  const projectDir = join(logDir, project);
+  if (!existsSync(projectDir)) return out;
+
+  // Cheap pass: order candidates by startTs without paying per-session folds.
+  const candidates = [];
+  for (const dirName of listSessionIds(projectDir)) {
+    let meta = null;
+    try { meta = JSON.parse(readFileSync(join(projectDir, 'sessions', dirName, 'meta.json'), 'utf-8')); } catch { /* journal is self-describing */ }
+    if (meta && meta.leader) continue; // teammate — folded into its leader's row
+    candidates.push({ dirName, startTs: (meta && meta.startTs) || '' });
+  }
+  // Newest first; dirName tiebreak matches listV2Logs' file tiebreak for stability.
+  candidates.sort((a, b) => b.startTs.localeCompare(a.startTs) || b.dirName.localeCompare(a.dirName));
+  out.total = candidates.length;
+
+  const start = (page - 1) * pageSize;
+  for (const c of candidates.slice(start, start + pageSize)) {
+    let s = null;
+    try { s = summarizeSessionPage(projectDir, c.dirName); } catch { continue; }
+    if (!s) continue;
+    if (s.leader) continue;
+    if (s.size === 0) continue;
+    if (s.discard) continue; // quota-probe orphans: never listed
+    out.items.push({
+      file: `v2:${project}/${s.sid}`,
+      kind: 'v2',
+      timestamp: compactLocalTs(s.startTs),
+      size: s.size,
+      turns: s.turns,
+      preview: s.preview || [],
+    });
+  }
+  return out;
+}
+
 /**
  * 1.7.0 v1 view: list legacy v1 `.jsonl` files, grouped per project — same row
  * shape as listV2Logs so LogTable renders both views unchanged. Every

server/lib/v2/adapter.js

@@ -27,16 +27,16 @@
 // (sessionId, seq) tie-break — field-equivalent to v1's "teammate writes the
 // leader's file".
 
-import { existsSync, readdirSync, readFileSync, statSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, dirname, basename } from 'node:path';
 import { reportSwallowed } from '../error-report.js';
 import { isMainAgentRequest } from '../interceptor-core.js';
-import { readPromptsHead, collectPromptsFromEvents } from '../user-prompt-extract.js';
-import { readSession, readJsonlTolerant, listSessionIds } from './replay.js';
+import { readSession } from './replay.js';
 import { iterateJsonlLines } from './jsonl-read.js';
 import { isDiscardableSession } from './session-select.js';
-import { blobPath, isSupportedWireFormat, dirSizeSync } from './layout.js';
+import { blobPath, isSupportedWireFormat } from './layout.js';
 import { SingleFlight } from './singleflight.js';
+import { listV2Sessions } from './session-list.js';
 
 // Same stamping rules as the v1 interceptor (KEEP IN SYNC: server/interceptor.js
 // requestEntry construction) — recomputed from the journal's url, not from kind,
@@ -1056,109 +1056,8 @@ export async function streamV2WindowedEntries(sessionDir, opts, onEntry) {
 
 // ─── session listing (spec §12, list entry pulled forward from S6a) ─────────
 
-/** Bounded head read: parse the FIRST JSONL line of a file without loading the
- *  whole thing (a main conversation's opening snapshot can be multi-MB; the
- *  list only wants a preview). Returns null on any shortfall. */
-function readFirstJsonLine(path, budget = 256 * 1024) {
-  let fd;
-  try {
-    fd = openSync(path, 'r');
-    const buf = Buffer.alloc(budget);
-    const n = readSync(fd, buf, 0, budget, 0);
-    const head = buf.toString('utf-8', 0, n);
-    const nl = head.indexOf('\n');
-    if (nl <= 0) return null; // no complete first line inside the budget
-    return JSON.parse(head.slice(0, nl));
-  } catch {
-    return null;
-  } finally {
-    if (fd !== undefined) { try { closeSync(fd); } catch { /* already closed */ } }
-  }
-}
-
-/**
- * Summarize every session under LOG_DIR/<project>/ for the log list (spec §12).
- * Deliberately cheap: journal lines only (small) + a bounded head read of the
- * main conversation's first epoch for the preview — conversation bodies are
- * never loaded. Teammate linkage is surfaced via `leader` so the caller can
- * fold those sessions into their leader's view instead of double-listing.
- * @returns {Array<{sid, dir, startTs, leader, turns, size, preview}>}
- */
-export function listV2Sessions(projectDir) {
-  const out = [];
-  for (const sid of listSessionIds(projectDir)) {
-    try {
-      const dir = join(projectDir, 'sessions', sid);
-      if (!existsSync(join(dir, 'journal.jsonl'))) continue;
-      let meta = null;
-      try { meta = JSON.parse(readFileSync(join(dir, 'meta.json'), 'utf-8')); } catch { /* tolerated — journal is self-describing */ }
-      if (meta && meta.wireFormat != null && !isSupportedWireFormat(meta.wireFormat)) {
-        // Reader version gate (spec §14): don't list a session this build
-        // can't read — a garbage preview/turn-count is worse than absence.
-        reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sid}: wireFormat=${meta.wireFormat}`));
-        continue;
-      }
-
-      // turns = main requests that completed (journal two-phase fold). The
-      // journal sentinel is checked in the same pass: per §14 the per-file
-      // sentinel WINS over meta.json, and readSession/adapter refuse such a
-      // session — listing it would show a phantom row that opens empty.
-      const reqKind = new Map();
-      let turns = 0;
-      let sentinelVersion = null;
-      let hasMainOrTeammate = false;
-      for (const line of readJsonlTolerant(join(dir, 'journal.jsonl'))) {
-        if (line.ph === 'req') {
-          reqKind.set(line.seq, line.kind);
-          if (line.kind === 'main' || line.kind === 'teammate') hasMainOrTeammate = true;
-        }
-        else if (line.ph === 'done' && reqKind.get(line.seq) === 'main') {
-          turns++;
-          reqKind.delete(line.seq); // fold duplicate done lines (§14)
-        } else if (line.ph === 'meta' && typeof line.wireFormat === 'number' && !isSupportedWireFormat(line.wireFormat)) {
-          sentinelVersion = line.wireFormat;
-          break;
-        }
-      }
-      if (sentinelVersion != null) {
-        reportSwallowed('v2-read.unsupported-wire-format', new Error(`${sid}: wireFormat=${sentinelVersion} (journal sentinel)`));
-        continue;
-      }
-
-      // preview = ALL user prompts of the session, from the prompts.jsonl
-      // display cache (written by V2Writer / the converter; bounded head read
-      // so the list stays O(budget) per session). Sessions predating the
-      // cache fall back to the first epoch's first line — routed through the
-      // shared extractor so command/caveat chrome never leaks into the row.
-      let preview = readPromptsHead(join(dir, 'prompts.jsonl'));
-      if (preview.length === 0) {
-        const first = readFirstJsonLine(join(dir, 'conversations', 'main', 'e0.jsonl'));
-        if (first && Array.isArray(first.msgs)) {
-          preview = collectPromptsFromEvents([first]);
-        }
-      }
-
-      out.push({
-        sid,
-        dir,
-        startTs: (meta && meta.startTs) || '',
-        leader: (meta && meta.leader) || null,
-        turns,
-        size: dirSizeSync(dir),
-        preview,
-        // Discardable-session verdict. KEEP IN SYNC: session-select.js
-        // isDiscardableSession is the canonical rule; this fold pre-computes
-        // it for free over the FULL journal (the canonical scan is 8MB-
-        // budgeted — intentional asymmetry, a first main sits at the head).
-        // When the fold says discard, the canonical predicate CONFIRMS it:
-        // readJsonlTolerant swallows an I/O error (Windows EBUSY/EPERM lock)
-        // into zero lines, which must KEEP the session, not hide it — the
-        // canonical path carries that error→keep direction (ioErrorResult).
-        // Main-bearing sessions never pay the extra read; probe journals are
-        // ~3 lines.
-        discard: !(meta && meta.leader) && !hasMainOrTeammate && isDiscardableSession(dir, meta),
-      });
-    } catch { /* one unreadable session must not break the list */ }
-  }
-  return out;
-}
+// listV2Sessions is re-exported from session-list.js (P0-A row cache, 2026-07-31).
+// The full per-session summarization logic (incl. the readFirstJsonLine preview
+// fallback) moved there; this re-export keeps the public API unchanged for all
+// callers (log-management.js, routes/im.js, tests).
+export { listV2Sessions };

server/lib/v2/convert-manager.js

@@ -10,6 +10,7 @@
 import { Worker } from 'node:worker_threads';
 import { join } from 'node:path';
 import { readConvertState } from './convert.js';
+import { _invalidate as _invalidateMigrationStatus } from './migrate-prompt.js';
 
 let _running = null; // { project, logDir, worker, startedAt, progress }
 let _lastError = null; // last worker-level failure (state file may lag on hard crashes)
@@ -36,7 +37,12 @@ export function startConvert(logDir, project) {
   worker.on('message', (msg) => {
     if (!msg || !_running || _running.worker !== worker) return;
     if (msg.type === 'progress') _running.progress = msg.progress;
-    else if (msg.type === 'final' && msg.error) _lastError = msg.error;
+    else if (msg.type === 'final') {
+      if (msg.error) _lastError = msg.error;
+      // A finished conversion immediately changes what migrationStatus returns
+      // for this project — drop the memo so the next call re-scans.
+      _invalidateMigrationStatus(_running.logDir, msg.project);
+    }
   });
   worker.on('error', (err) => {
     _lastError = String(err && err.message || err);

server/lib/v2/migrate-prompt.js

@@ -5,10 +5,23 @@
 // pending unless the convert state marks it done AT ITS CURRENT SIZE (the
 // converter's trust rule, convert.js), because the converter never deletes
 // v1 sources ("files exist" alone is not "migration needed").
+//
+// P0-B (2026-07-31): 10s TTL memo per (logDir, project). migrationStatus is
+// called on every SSE connect (events.js), every list refresh (logs.js), and
+// every workspace boot — each call stat-scans ALL v1 files of ALL projects.
+// The memo collapses repeat calls to a Map lookup. `now` is injectable for
+// tests (same house style as singleflight.js). Invalidation hook: the convert
+// manager calls _invalidate() when its worker posts {type:'final'} (bypasses
+// the 1s progress throttle), so a finished conversion is reflected immediately.
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import { listV1Files, listConvertibleProjects, readConvertState } from './convert.js';
 
+const TTL_MS = 10_000;
+/** @type {Map<string, {value: object, expiresAt: number}>} */
+const _memo = new Map();
+let _now = Date.now;
+
 /** Pending v1 files + bytes of ONE project dir. */
 function pendingOf(projectDir) {
   const state = readConvertState(projectDir);
@@ -36,22 +49,47 @@ function pendingOf(projectDir) {
 /**
  * Migration status of one project (plus how many OTHER projects also have
  * pending v1 logs — the prompt mentions `ccv convert --all` for those).
+ * Memoized for TTL_MS per (logDir, project); see module header for the
+ * invalidation contract.
  * @param {string} logDir - LOG_DIR root
  * @param {string} project - project directory name ('' → not pending)
  * @returns {{pending: boolean, files: number, totalBytes: number, otherProjects: number}}
  */
 export function migrationStatus(logDir, project) {
   const empty = { pending: false, files: 0, totalBytes: 0, otherProjects: 0 };
   if (!logDir || !project) return empty;
+  const cacheKey = `${logDir}\0${project}`;
+  const cached = _memo.get(cacheKey);
+  if (cached && _now() < cached.expiresAt) return cached.value;
   try {
     const { files, totalBytes } = pendingOf(join(logDir, project));
     let otherProjects = 0;
     for (const p of listConvertibleProjects(logDir)) {
       if (p === project) continue;
       if (pendingOf(join(logDir, p)).files > 0) otherProjects++;
     }
-    return { pending: files > 0, files, totalBytes, otherProjects };
+    const value = { pending: files > 0, files, totalBytes, otherProjects };
+    _memo.set(cacheKey, { value, expiresAt: _now() + TTL_MS });
+    return value;
   } catch {
     return empty;
   }
 }
+
+/** Drop the memo for one (or all) projects — called by the convert manager
+ *  when a conversion worker finishes, and by tests. */
+export function _invalidate(logDir, project) {
+  if (logDir === undefined) { _memo.clear(); return; }
+  _memo.delete(`${logDir}\0${project}`);
+}
+
+/** Test hook: replace the clock (pass `() => t`); call without args to restore. */
+export function _setNowForTest(fn) {
+  _now = fn || Date.now;
+}
+
+/** Test hook: drop all memoized entries. */
+export function _resetForTest() {
+  _memo.clear();
+  _now = Date.now;
+}