cc-viewer 1.7.11 → 1.7.13

package/server/lib/v2/session-list.js

@@ -0,0 +1,276 @@
+// Wire Format v2 — session-row cache for the log list (P0-A, 2026-07-31).
+//
+// `GET /api/local-logs` re-scans every session on every call: full journal
+// fold, recursive dir walk, 256KB prompts head read, meta read — all sync,
+// all blocking the event loop. With 100+ sessions this costs seconds.
+//
+// The journal is append-only (the single write path is Journal.writeReq/
+// writeDone → AsyncWriteQueue.appendTo; creation is a one-time 'wx' sentinel;
+// no truncate/rename/unlink anywhere). Content changes land in the journal
+// LAST within a request (blobs → conversation → journal line → prompts), so
+// (size, mtimeMs) is an exact freshness key for everything up to the journal
+// line. prompts.jsonl is appended strictly AFTER the journal line (and is
+// backfilled without a journal write on crash-resume), so the freshness key
+// spans BOTH files: `journalSize:journalMtimeMs:promptsSize:promptsMtimeMs`.
+// A repeated key means identical row inputs; any content change bumps one of
+// the two stats.
+//
+// Cache shape: Map<projectDir, Map<sid, Row>> keyed by the project dir, with
+// per-sid rows keyed by the freshness pair above. Insertion-order eviction
+// caps the project map at MAX_PROJECTS. Rows are re-copied on return (see
+// copyRow) so callers can't mutate the cache.
+
+import { statSync, existsSync, readFileSync, openSync, readSync, closeSync } from 'node:fs';
+import { join } from 'node:path';
+import { listSessionIds, readJsonlTolerant } from './replay.js';
+import { readPromptsHead, collectPromptsFromEvents } from '../user-prompt-extract.js';
+import { isDiscardableSession } from './session-select.js';
+import { isSupportedWireFormat, dirSizeSync } from './layout.js';
+import { reportSwallowed } from '../error-report.js';
+
+const MAX_PROJECTS = 32;
+
+// ─── internal helpers (verbatim extraction from adapter.js) ──────────────────
+
+/** 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 */ } }
+  }
+}
+
+// ─── per-session summarization ───────────────────────────────────────────────
+
+/**
+ * Compute the summary row for one session dir. This is the exact logic that
+ * used to live inline in listV2Sessions (adapter.js). All gates and error
+ * directions are preserved verbatim:
+ *
+ *   - wireFormat gate (meta.json) → skip + reportSwallowed
+ *   - wireFormat gate (journal sentinel) → skip + reportSwallowed
+ *   - error→keep: journal stat failure skips the row, never caches
+ *   - discard short-circuit: !leader && !hasMainOrTeammate && isDiscardableSession()
+ *   - no "journal non-empty" guard — torn creation is tolerated as turns:0
+ *
+ * @returns {object|null} row {sid, dir, startTs, leader, turns, size, preview, discard}
+ *   or null if the session should be skipped
+ */
+function summarizeSession(projectDir, sid) {
+  const dir = join(projectDir, 'sessions', sid);
+  // Journal existence is the cheapest gate — a session dir without one is
+  // either torn at creation or not a session at all.
+  if (!existsSync(join(dir, 'journal.jsonl'))) return null;
+  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}`));
+    return null;
+  }
+
+  // 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)`));
+    return null;
+  }
+
+  // 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]);
+    }
+  }
+
+  return {
+    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),
+  };
+}
+
+// ─── row cache ───────────────────────────────────────────────────────────────
+
+/** Map<projectDir, Map<sid, {key, row}>> — insertion-order eviction. */
+const _cache = new Map();
+
+function _evictProjects() {
+  while (_cache.size > MAX_PROJECTS) {
+    const oldest = _cache.keys().next().value;
+    _cache.delete(oldest);
+  }
+}
+
+/**
+ * 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.
+ *
+ * Cached: repeat calls with unchanged journals return instantly (~1-3ms for
+ * 100 sessions, vs. seconds for a full rescan).
+ *
+ * @returns {Array<{sid, dir, startTs, leader, turns, size, preview, discard}>}
+ */
+export function listV2Sessions(projectDir) {
+  const sids = listSessionIds(projectDir);
+  const sidSet = new Set(sids); // O(1) prune lookups — sids.includes() per cached sid is O(N²)
+  let projectCache = _cache.get(projectDir);
+  if (!projectCache) {
+    projectCache = new Map();
+    _cache.set(projectDir, projectCache);
+    _evictProjects();
+  }
+  // Prune deleted/migrated sessions: a sid no longer in the readdir is gone.
+  for (const sid of projectCache.keys()) {
+    if (!sidSet.has(sid)) projectCache.delete(sid);
+  }
+  const out = [];
+  for (const sid of sids) {
+    try {
+      const dir = join(projectDir, 'sessions', sid);
+      let key;
+      try {
+        const jst = statSync(join(dir, 'journal.jsonl'));
+        // Freshness key spans journal AND prompts.jsonl: the display cache is
+        // appended strictly AFTER the journal line (v2-writer.js §5), so a list
+        // call landing between the two queue drains — or a crash-resume
+        // backfill that appends prompts without any journal write — must not
+        // freeze a pre-prompts preview under an unchanged journal key. Absent
+        // prompts use a placeholder: their first write always follows a journal
+        // append, except exactly that backfill path, which this key detects.
+        let pKey = '-:-';
+        try {
+          const pst = statSync(join(dir, 'prompts.jsonl'));
+          pKey = `${pst.size}:${pst.mtimeMs}`;
+        } catch { /* prompts.jsonl not written yet */ }
+        key = `${jst.size}:${jst.mtimeMs}:${pKey}`;
+      } catch {
+        continue; // journal unreadable → skip row, never cache
+      }
+      const cached = projectCache.get(sid);
+      if (cached && cached.key === key) {
+        out.push(copyRow(cached.row)); // defensive copy — callers must not mutate cache
+        continue;
+      }
+      const row = summarizeSession(projectDir, sid);
+      if (row) {
+        projectCache.set(sid, { key, row });
+        out.push(copyRow(row));
+      }
+      // row === null → session skipped (wireFormat gate, sentinel, etc.) — don't cache
+    } catch { /* one unreadable session must not break the list */ }
+  }
+  return out;
+}
+
+/** Copy a row for delivery: nested `preview` (array) and `leader` (object) are
+ *  re-copied so a caller mutating what it received can never poison the cache
+ *  entry shared by every viewer of the project. */
+function copyRow(row) {
+  return {
+    ...row,
+    ...(row.leader ? { leader: { ...row.leader } } : {}),
+    preview: [...row.preview],
+  };
+}
+
+/**
+ * Summarize ONE session for the paginated list (server-side paging, 2026-07-31).
+ * Same row + same cache as listV2Sessions: a key hit returns the cached row
+ * without re-folding the journal; a miss computes and stores it. The caller
+ * (listV2LogsPage) has already decided this sid is on the current page, so only
+ * these sessions ever pay the summarize cost.
+ *
+ * @returns {object|null} row {sid, dir, startTs, leader, turns, size, preview, discard}
+ *   or null if the session should be skipped (wireFormat gate, sentinel, no journal)
+ */
+export function summarizeSessionPage(projectDir, sid) {
+  const dir = join(projectDir, 'sessions', sid);
+  let key;
+  try {
+    const jst = statSync(join(dir, 'journal.jsonl'));
+    let pKey = '-:-';
+    try {
+      const pst = statSync(join(dir, 'prompts.jsonl'));
+      pKey = `${pst.size}:${pst.mtimeMs}`;
+    } catch { /* prompts.jsonl not written yet */ }
+    key = `${jst.size}:${jst.mtimeMs}:${pKey}`;
+  } catch {
+    return null; // journal unreadable → skip, never cache
+  }
+  let projectCache = _cache.get(projectDir);
+  if (!projectCache) {
+    projectCache = new Map();
+    _cache.set(projectDir, projectCache);
+    _evictProjects();
+  }
+  const cached = projectCache.get(sid);
+  if (cached && cached.key === key) return copyRow(cached.row);
+  const row = summarizeSession(projectDir, sid);
+  if (row) {
+    projectCache.set(sid, { key, row });
+    return copyRow(row);
+  }
+  return null; // skipped (wireFormat gate, sentinel, etc.) — don't cache
+}
+
+/** Test hook: drop all cached rows. */
+export function _resetForTest() {
+  _cache.clear();
+}

package/server/lib/v2/session-select.js

@@ -215,10 +215,10 @@ export function sessionHasMainOrTeammateReq(dir) {
  * the moment a dir gains its first main req, the predicate flips and every
  * surface picks it up on its next scan/poll.
  *
- * KEEP IN SYNC: adapter.js listV2Sessions pre-computes the same verdict
- * inline (hasMainOrTeammate inside its existing full journal fold — unbounded,
- * vs this predicate's 8MB budget; intentional asymmetry) and then CONFIRMS a
- * discard through this predicate so the error→keep direction is shared.
+ * KEEP IN SYNC: session-list.js summarizeSession pre-computes the same verdict
+ * inline (hasMainOrTeammate inside its full journal fold — unbounded, vs this
+ * predicate's 8MB budget; intentional asymmetry) and then CONFIRMS a discard
+ * through this predicate so the error→keep direction is shared.
  * Change the rule here and there together.
  *
  * @param {string} dir - absolute session dir

package/server/routes/events.js

@@ -320,7 +320,7 @@ async function events(req, res, parsedUrl, isLocal, deps) {
       if (!latestContextWindow) {
         const usage = entry.response?.body?.usage;
         if (usage) {
-          const contextSize = getContextSizeForModel(entry.body?.model);
+          const contextSize = getContextSizeForModel(entry);
           const cw = buildContextWindowEvent(usage, contextSize);
           if (cw) latestContextWindow = cw;
         }

package/server/routes/logs.js

@@ -1,14 +1,14 @@
 // Local log management routes (moved verbatim from server.js handleRequest).
-import { existsSync, realpathSync, statSync, createReadStream, mkdtempSync, rmSync } from 'node:fs';
+import { existsSync, realpathSync, statSync, createReadStream, mkdtempSync, rmSync, readdirSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { tmpdir } from 'node:os';
 import AdmZip from 'adm-zip';
 import { LOG_DIR } from '../../findcc.js';
 import { _projectName, _v2Writer } from '../interceptor.js';
-import { listV2Logs, listLocalLogs, countListedV1Files, deleteLogFiles, validateLogPath } from '../lib/log-management.js';
+import { listV2Logs, listV2LogsPage, listLocalLogs, countListedV1Files, deleteLogFiles, validateLogPath } from '../lib/log-management.js';
 import { countLogEntries, streamRawEntriesAsync, readTailEntries } from '../lib/log-stream.js';
 import { sseHead, sseWrite, wireEnd } from '../lib/wire-compress.js';
-import { dirSizeSync } from '../lib/v2/layout.js';
+import { dirSizeSync, sanitizePathComponent } from '../lib/v2/layout.js';
 import { extractV2Zip } from '../lib/log-zip.js';
 import { startConvert, stopConvert, convertStatus } from '../lib/v2/convert-manager.js';
 import { migrationStatus } from '../lib/v2/migrate-prompt.js';
@@ -32,18 +32,60 @@ async function localLogs(req, res, parsedUrl, isLocal, deps) {
       res.end(JSON.stringify(v1));
       return;
     }
-    const result = listV2Logs(LOG_DIR, _projectName);
+    // Server-side pagination (2026-07-31): ?page=&pageSize= switches the v2
+    // list to a per-project page — only the requested page's sessions are
+    // summarized. Response shape becomes {items, total, page, pageSize} plus
+    // the same _-prefixed side signals below. No params = legacy grouped shape.
+    const pageParam = parsedUrl?.searchParams?.get('page');
+    let payload;
+    if (pageParam != null) {
+      // Optional ?project= views another project's logs (the modal's project
+      // switcher). Strict-compare against sanitizePathComponent (same pattern
+      // as parseV2Ref) so '..'/ separators can't traverse out of LOG_DIR;
+      // absent/empty falls back to the active project.
+      const rawProject = parsedUrl.searchParams.get('project');
+      let target = _projectName;
+      if (rawProject) {
+        if (rawProject !== sanitizePathComponent(rawProject)) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Invalid project name' }));
+          return;
+        }
+        target = rawProject;
+      }
+      const page = Math.max(1, parseInt(pageParam, 10) || 1);
+      const pageSize = Math.min(200, Math.max(1, parseInt(parsedUrl.searchParams.get('pageSize'), 10) || 50));
+      payload = listV2LogsPage(LOG_DIR, target, { page, pageSize });
+      // _currentProject must stay the ACTIVE project (_projectName), not the
+      // viewed one (listV2LogsPage sets it to `target`): the frontend's global
+      // currentProject drives the sidebar / migration counts / v1 banner, and
+      // the viewed project is carried separately by its own logViewProject
+      // state. Overwriting it here would let "viewing project A" leak into
+      // global state. _viewedProject tells the client which project this page
+      // actually lists.
+      payload._currentProject = _projectName || '';
+      payload._viewedProject = target || '';
+      // Project list for the modal's switcher dropdown. LOG_DIR's top level
+      // holds one dir per project (recycle dirs live INSIDE each project, so
+      // nothing to filter here) — but skip dot-prefixed hidden dirs.
+      try {
+        payload._allProjects = readdirSync(LOG_DIR, { withFileTypes: true })
+          .filter(e => e.isDirectory() && !e.name.startsWith('.')).map(e => e.name).sort();
+      } catch { payload._allProjects = []; }
+    } else {
+      payload = listV2Logs(LOG_DIR, _projectName);
+    }
     // Legacy v1 files are not in this list — surface two distinct signals:
     //  - _v1FileCount: v1 files ON DISK (gates the v1-view entry link; the
     //    converter never deletes sources, so this outlives a finished migration)
     //  - _unmigratedV1Count/Bytes: files still AWAITING migration (gates the
     //    migrate button + hint inside the v1 view and the startup prompt)
     const mig = migrationStatus(LOG_DIR, _projectName || '');
-    result._unmigratedV1Count = mig.files;
-    result._unmigratedV1Bytes = mig.totalBytes;
-    result._v1FileCount = _projectName ? countListedV1Files(join(LOG_DIR, _projectName)) : 0;
+    payload._unmigratedV1Count = mig.files;
+    payload._unmigratedV1Bytes = mig.totalBytes;
+    payload._v1FileCount = _projectName ? countListedV1Files(join(LOG_DIR, _projectName)) : 0;
     res.writeHead(200, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(result));
+    res.end(JSON.stringify(payload));
   } catch (err) {
     res.writeHead(500, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ error: err.message }));

package/src/utils/effectiveModel.js

@@ -7,6 +7,10 @@
  * server-reported model in `response.body.model` (authoritative under proxy
  * hot-switch) over the client-supplied `body.model`. Returns null when both
  * are missing — callers should fall back to a sensible default.
+ *
+ * KEEP IN SYNC: server/lib/context-watcher.js getContextSizeForModel reuses
+ * this precedence for its entry path — changing the priority here must be
+ * mirrored there (and vice versa).
  */
 export function getEffectiveModel(request) {
   return request?.response?.body?.model || request?.body?.model || null;

package/src/utils/helpers.js

@@ -20,8 +20,9 @@ export {
   sumCacheCreationTokens,
   sumUsageInputTokens,
   sumUsageContextTokens,
+  getCalibrationModel,
 } from '../../server/lib/context-rules.js';
-import { classifyContextWindow, adaptContextWindow } from '../../server/lib/context-rules.js';
+import { classifyContextWindow, adaptContextWindow, getCalibrationModel } from '../../server/lib/context-rules.js';
 
 // getEffectiveModel moved to ./effectiveModel.js (pure, node-testable — sessionMerge/sessionManager
 // import it without helpers' Vite-only svg imports); re-exported here to keep import paths stable.
@@ -57,7 +58,9 @@ const CALIBRATION_TOKEN_MAP = {
 export function resolveCalibrationTokens(calibrationModel, lastMainAgent, projectModelHint = null) {
   const direct = CALIBRATION_TOKEN_MAP[calibrationModel];
   if (direct) return direct;
-  const lastModel = lastMainAgent ? getEffectiveModel(lastMainAgent) : null;
+  // 校准用 getCalibrationModel:请求名带显式 [Nk]/[Nm] 后缀时优先(用户热切换配置的
+  // 1M 意图),不被上游响应归一化(如 k3[1m]→裸 k3)覆盖;其余回退 response-first。
+  const lastModel = lastMainAgent ? getCalibrationModel(lastMainAgent) : null;
   // 优先用真实 mainAgent 信号；haiku 一律视为 init ping 噪声，跳过
   if (typeof lastModel === 'string' && lastModel && !/haiku/i.test(lastModel)) {
     return classifyContextWindow(lastModel);
@@ -334,7 +337,7 @@ const MODEL_PROVIDERS = [
     match: /kimi|moonshot|^k3$/i,
     name: 'Kimi',
     color: 'var(--bg-model-avatar)',
-    svg: '<svg t="1771495664798" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="6649" width="200" height="200"><path d="M731.062857 590.262857v318.317714h-148.589714V443.977143a146.285714 146.285714 0 0 1-146.285714 146.285714l-214.491429-0.036571v318.354285H73.142857V165.814857h148.553143v275.858286h180.882286l119.771428-275.858286h167.753143l-67.84 156.269714a255.524571 255.524571 0 0 1-106.678857 119.588572h66.925714a148.553143 148.553143 0 0 1 148.516572 148.589714z m120.758857-473.965714a99.035429 99.035429 0 0 1 0 198.070857h-99.035428V215.332571a99.035429 99.035429 0 0 1 99.035428-99.035428z" fill="currentColor" p-id="6650"></path></svg>',
+    svg: '<svg class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" width="200" height="200"><path d="M932.096 0a82.048 82.048 0 1 1 0 164.096h-72.352a9.568 9.568 0 0 1-9.664-9.632V82.016A82.048 82.048 0 0 1 932.096 0z" fill="#1783FF"></path><path d="M472.064 477.856l309.76-307.2c5.888-5.792 2.56-17.472-4.96-17.472h-166.72a7.008 7.008 0 0 0-5.056 2.112L271.456 486.24c-5.12 5.12-12.8 0.576-12.8-7.68V162.976c0-5.376-3.584-9.792-7.936-9.792H135.936c-4.352 0-7.936 4.416-7.936 9.792V843.52c0 5.44 3.584 9.824 7.936 9.824h114.784c4.352 0 7.936-4.288 7.936-9.824v-138.656c0-2.912 1.024-5.728 2.88-7.616l103.424-102.656a6.72 6.72 0 0 1 8.8-0.928l276.64 203.616a328.64 328.64 0 0 0 147.296 54.688c4.608 0.512 8.544-4 8.544-9.824V711.68c0-4.96-2.912-9.056-7.008-9.632a214.528 214.528 0 0 1-86.432-34.496l-239.456-173.472c-5.024-3.328-5.632-11.936-1.184-16.224h-0.096z" fill="currentColor"></path></svg>',
   },
   {
     match: /glm|chatglm/i,