cc-viewer 1.6.348 → 1.7.1

package/server/routes/logs.js

@@ -1,18 +1,47 @@
 // Local log management routes (moved verbatim from server.js handleRequest).
-import { existsSync, realpathSync, statSync, createReadStream, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, realpathSync, statSync, createReadStream, mkdtempSync, rmSync } 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, LOG_FILE, getAgentSpawnRegistrySnapshot } from '../interceptor.js';
-import { listLocalLogs, deleteLogFiles, mergeLogFiles, archiveLogFiles, validateLogPath, findPreviousSegment } from '../lib/log-management.js';
-import { countLogEntries, streamRawEntriesAsync, readTailEntries, collectFilteredRawEntriesAsync } from '../lib/log-stream.js';
-import { isTeammateLikeEntry } from '../lib/teammate-detect.js';
+import { _projectName, _v2Writer } from '../interceptor.js';
+import { listV2Logs, 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 { extractV2Zip } from '../lib/log-zip.js';
+import { startConvert, stopConvert, convertStatus } from '../lib/v2/convert-manager.js';
+import { migrationStatus } from '../lib/v2/migrate-prompt.js';
+
+// Cap for the in-memory zip build (adm-zip toBuffer holds the whole archive in
+// heap) and the upload accumulation — the repo has an OOM history, so both the
+// zipped source folder and the uploaded archive are bounded before buffering.
+const MAX_UPLOAD = 300 * 1024 * 1024;
+// Download-zip source cap; read per-request so CCV_MAX_ZIP_SOURCE is an ops
+// tunable (and a test seam) without a restart.
+const maxZipSource = () => Number(process.env.CCV_MAX_ZIP_SOURCE) || 300 * 1024 * 1024;
 
 async function localLogs(req, res, parsedUrl, isLocal, deps) {
   try {
-    // 按当前实例 pid 硬隔离日志列表；`?all=1` 越过过滤看全部实例（顶部「显示全部」开关）。
-    const instanceId = (deps && deps.instanceId) || null;
-    const showAll = parsedUrl?.searchParams?.get('all') === '1';
-    const result = await listLocalLogs(LOG_DIR, _projectName, { instanceId, showAll });
+    // 1.7.0: the DEFAULT list is v2 sessions, unconditionally. `?view=v1`
+    // serves the legacy-file list for the modal's v1 view (list + migrate +
+    // open + delete for leftovers the converter never removes).
+    if (parsedUrl?.searchParams?.get('view') === 'v1') {
+      const v1 = await listLocalLogs(LOG_DIR, _projectName);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(v1));
+      return;
+    }
+    const result = 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;
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify(result));
   } catch (err) {
@@ -28,7 +57,69 @@ async function downloadLog(req, res, parsedUrl) {
     res.end(JSON.stringify({ error: 'Invalid file name' }));
     return;
   }
-  if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.zip')) {
+  // wire-v2 S5: rebuilt download for v2 sessions — the adapter stream as a v1
+  // `.jsonl`. `format=raw` (session-dir zip) is the S6a half of the S0 contract:
+  // a lossless zip of the whole session folder, the transport for round-tripping
+  // a v2 session (folder) back through the upload-and-parse flow.
+  if (file.startsWith('v2:')) {
+    if (parsedUrl.searchParams.get('format') === 'raw') {
+      try {
+        const sessionDir = validateLogPath(LOG_DIR, file);
+        if (dirSizeSync(sessionDir) > maxZipSource()) {
+          res.writeHead(413, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Session too large to zip', code: 'TOO_LARGE' }));
+          return;
+        }
+        const dirName = basename(sessionDir);
+        const zip = new AdmZip();
+        // Wrap the folder under `<dirName>/` and skip dotfiles (.DS_Store etc.).
+        // adm-zip passes the zip-internal path (incl. the `<dirName>/` root) to
+        // the filter, so match on any path segment starting with a dot.
+        zip.addLocalFolder(sessionDir, dirName, (n) => !/(^|\/)\./.test(n.replace(/\\/g, '/')));
+        const buf = zip.toBuffer();
+        res.writeHead(200, {
+          'Content-Type': 'application/zip',
+          'Content-Disposition': `attachment; filename="${encodeURIComponent(`${dirName}.zip`)}"`,
+          'Content-Length': buf.length,
+        });
+        res.end(buf);
+      } catch (err) {
+        if (!res.headersSent) {
+          const status = err.code === 'NOT_FOUND' ? 404 : err.code === 'ACCESS_DENIED' ? 403 : 500;
+          // Don't leak internal messages (may contain absolute paths) on 500 —
+          // genericize like the upload handler does.
+          res.writeHead(status, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: status >= 500 ? 'server_error' : err.message }));
+        } else {
+          res.end();
+        }
+      }
+      return;
+    }
+    try {
+      const sessionDir = validateLogPath(LOG_DIR, file);
+      res.writeHead(200, {
+        'Content-Type': 'application/octet-stream',
+        'Content-Disposition': `attachment; filename="${encodeURIComponent(`${basename(sessionDir)}.v2-rebuilt.jsonl`)}"`,
+        'Transfer-Encoding': 'chunked',
+      });
+      await streamRawEntriesAsync(sessionDir, (raw) => {
+        res.write(raw);
+        res.write('\n---\n');
+      });
+      res.end();
+    } catch (err) {
+      if (!res.headersSent) {
+        const status = err.code === 'NOT_FOUND' ? 404 : err.code === 'ACCESS_DENIED' ? 403 : 500;
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: err.message }));
+      } else {
+        res.end();
+      }
+    }
+    return;
+  }
+  if (!file.endsWith('.jsonl')) {
     res.writeHead(400, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ error: 'Invalid file type' }));
     return;
@@ -48,10 +139,7 @@ async function downloadLog(req, res, parsedUrl) {
       return;
     }
     const format = parsedUrl.searchParams.get('format');
-    // 默认下载重建后的 .jsonl；raw 下载原始字节（.zip 或 .jsonl 视实际而定）
-    const fileName = (format !== 'raw' && file.endsWith('.jsonl.zip'))
-      ? basename(file).slice(0, -4)
-      : basename(file);
+    const fileName = basename(file);
     // Delta storage: format=raw 下载原始文件；默认下载重建后的全量格式
     if (format === 'raw') {
       const stat = statSync(realPath);
@@ -89,20 +177,24 @@ async function localLog(req, res, parsedUrl) {
     return;
   }
 
-  // 验证文件类型：允许 .jsonl 或 .jsonl.zip
-  if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.zip')) {
+  // 验证文件类型：v2 寻址（spec §12）；直连 .jsonl 保留为未迁移日志的逃生舱
+  // （代码与转换器共享，UI 无入口——1.7.0 决策）。
+  const isV2Ref = file.startsWith('v2:');
+  if (!isV2Ref && !file.endsWith('.jsonl')) {
     res.writeHead(400, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: 'Invalid file type. Only .jsonl(.zip) files are allowed.' }));
+    res.end(JSON.stringify({ error: 'Invalid file type. Only .jsonl files are allowed.' }));
     return;
   }
 
   try {
     // 独立 SSE 流：直接向请求方返回 event-stream，不走 /events 广播
-    validateLogPath(LOG_DIR, file);
-    const filePath = join(LOG_DIR, file);
+    // v2 寻址时 validateLogPath 返回 session 目录绝对路径，log-stream 据此分派适配器
+    const filePath = validateLogPath(LOG_DIR, file);
     const limitVal = Math.min(parseInt(parsedUrl.searchParams.get('limit'), 10) || 0, 500);
 
-    res.writeHead(200, {
+    // Negotiated Content-Encoding (br|identity) — every subsequent byte MUST
+    // go through sseWrite/wireEnd (see server/lib/wire-compress.js).
+    sseHead(req, res, 200, {
       'Content-Type': 'text/event-stream',
       'Cache-Control': 'no-cache',
       'Connection': 'keep-alive',
@@ -111,27 +203,27 @@ async function localLog(req, res, parsedUrl) {
     if (limitVal > 0) {
       // 尾部加载模式：跳过 countLogEntries，只读文件末尾
       const { entries, hasMore, oldestTimestamp, estimatedTotal } = await readTailEntries(filePath, { limit: limitVal });
-      res.write(`event: load_start\ndata: ${JSON.stringify({ total: estimatedTotal, incremental: false, hasMore, oldestTs: oldestTimestamp })}\n\n`);
+      sseWrite(res, `event: load_start\ndata: ${JSON.stringify({ total: estimatedTotal, incremental: false, hasMore, oldestTs: oldestTimestamp })}\n\n`);
       for (const raw of entries) {
-        res.write('event: load_chunk\ndata: [');
-        res.write(raw.includes('\n') ? raw.replace(/\n/g, '') : raw);
-        res.write(']\n\n');
+        sseWrite(res, 'event: load_chunk\ndata: [');
+        sseWrite(res, raw.includes('\n') ? raw.replace(/\n/g, '') : raw);
+        sseWrite(res, ']\n\n');
       }
     } else {
       // 全量加载模式（向后兼容）
       const total = await countLogEntries(filePath);
-      res.write(`event: load_start\ndata: ${JSON.stringify({ total, incremental: false })}\n\n`);
+      sseWrite(res, `event: load_start\ndata: ${JSON.stringify({ total, incremental: false })}\n\n`);
       await streamRawEntriesAsync(filePath, (raw) => {
-        res.write('event: load_chunk\ndata: [');
-        res.write(raw.includes('\n') ? raw.replace(/\n/g, '') : raw);
-        res.write(']\n\n');
+        sseWrite(res, 'event: load_chunk\ndata: [');
+        sseWrite(res, raw.includes('\n') ? raw.replace(/\n/g, '') : raw);
+        sseWrite(res, ']\n\n');
       });
     }
-    res.write(`event: load_end\ndata: {}\n\n`);
-    res.end();
+    sseWrite(res, `event: load_end\ndata: {}\n\n`);
+    wireEnd(res);
   } catch (err) {
     // 如果 headers 未发送，返回 JSON 错误；否则关闭连接
-    // 落 stderr 让用户在 ccv 终端能看到 .jsonl.zip 解压失败等具体原因（SSE onerror 在客户端
+    // 落 stderr 让用户在 ccv 终端能看到具体原因（SSE onerror 在客户端
     // 不携带错误明细，只能从服务端日志反查）
     console.error('[local-log]', file, err && err.stack || err);
     if (!res.headersSent) {
@@ -139,7 +231,7 @@ async function localLog(req, res, parsedUrl) {
       res.writeHead(status, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ error: err.message }));
     } else {
-      res.end();
+      wireEnd(res); // flush the encoder trailer if the stream was compressed
     }
   }
 }
@@ -155,7 +247,7 @@ function deleteLogs(req, res, parsedUrl, isLocal, deps) {
         res.end(JSON.stringify({ error: 'No files specified' }));
         return;
       }
-      const results = deleteLogFiles(LOG_DIR, files);
+      const results = deleteLogFiles(LOG_DIR, files, { liveSessionDir: _v2Writer.currentSessionDir() });
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ results }));
     } catch {
@@ -165,162 +257,115 @@ function deleteLogs(req, res, parsedUrl, isLocal, deps) {
   });
 }
 
-function mergeLogs(req, res, parsedUrl, isLocal, deps) {
-  let body = '';
-  req.on('data', chunk => { body += chunk; if (body.length > deps.MAX_POST_BODY) req.destroy(); });
-  req.on('end', async () => {
-    try {
-      const { files } = JSON.parse(body);
-      const merged = await mergeLogFiles(LOG_DIR, files);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ ok: true, merged }));
-    } catch (err) {
-      const status = err.code === 'NOT_FOUND' ? 404 : err.code === 'INVALID_INPUT' ? 400 : 500;
-      res.writeHead(status, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: err.message }));
-    }
-  });
+// wire-v2 S8: one-click v1→v2 migration of the CURRENT project, run by the
+// resident convert-manager worker. GET = status snapshot for the modal's
+// polling; POST {action:'start'|'stop'} controls the task. Local/LAN exposure
+// via the existing auth middleware (same posture as delete-logs).
+function getWireV2Convert(req, res) {
+  res.writeHead(200, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(convertStatus(LOG_DIR, _projectName || '')));
 }
 
-function archiveLogs(req, res, parsedUrl, isLocal, deps) {
+function postWireV2Convert(req, res, parsedUrl, isLocal, deps) {
   let body = '';
   req.on('data', chunk => { body += chunk; if (body.length > deps.MAX_POST_BODY) req.destroy(); });
   req.on('end', () => {
     try {
-      const { files } = JSON.parse(body);
-      if (!Array.isArray(files) || files.length === 0) {
+      const { action } = JSON.parse(body || '{}');
+      if (action !== 'start' && action !== 'stop') {
         res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'No files specified' }));
+        res.end(JSON.stringify({ error: 'action must be "start" or "stop"' }));
         return;
       }
-      if (files.length > 50) {
+      if (action === 'start' && !_projectName) {
         res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Too many files (max 50 per request)' }));
+        res.end(JSON.stringify({ error: 'no active project' }));
         return;
       }
-      const result = archiveLogFiles(LOG_DIR, files);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify(result));
-    } catch {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ error: 'Invalid JSON' }));
+      const result = action === 'start' ? startConvert(LOG_DIR, _projectName) : stopConvert();
+      res.writeHead(result.ok ? 200 : 409, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result.ok ? { ok: true } : { error: result.error }));
+    } catch (err) {
+      const status = err instanceof SyntaxError ? 400 : 500;
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err?.message || 'internal error' }));
     }
   });
 }
 
-// Bounded head read: returns the parsed first frame of a live log file when it
-// is a rotation-context sentinel, else null. Never scans past the first frame.
-function readHeadRotationContext(file) {
-  try {
-    if (!file || !existsSync(file)) return null;
-    const fd = openSync(file, 'r');
-    let head;
-    try {
-      const buf = Buffer.alloc(64 * 1024);
-      const n = readSync(fd, buf, 0, buf.length, 0);
-      head = buf.toString('utf-8', 0, n);
-    } finally {
-      closeSync(fd);
-    }
-    const frameEnd = head.indexOf('\n---\n');
-    if (frameEnd <= 0) return null;
-    const entry = JSON.parse(head.slice(0, frameEnd));
-    return entry && entry.ccvRotationContext ? entry : null;
-  } catch {
-    return null;
-  }
-}
-
-// Cheap substring gate evaluated before JSON.parse: every teammate shape
-// carries at least one of these markers in its raw JSON (external tag,
-// proxy-mode system marker, native SDK prompt). Giant MainAgent checkpoint
-// frames are skipped without parsing.
-function teammateRawPrefilter(raw) {
-  return raw.includes('"teammate"')
-    || raw.includes('agent in a team')
-    || raw.includes('Agent Teammate Communication')
-    || raw.includes('You are a Claude agent');
-}
-
-// Single-flight + short-TTL cache for the previous-segment scan. A real
-// predecessor is ~300MB and the parse pass transiently costs hundreds of MB of
-// RSS; every non-incremental cold load triggers the route, so concurrent
-// viewers / rapid refreshes must share one scan. Keyed by path+size+mtime —
-// the old segment can still GROW (external teammates keep appending to it),
-// which changes the key and forces a rescan.
-const PREV_SCAN_TTL_MS = 60 * 1000;
-let _prevScanCache = null; // { key, promise, expiresAt }
-
-function collectPrevSegmentCached(prev, predicate, opts) {
-  let st = null;
-  try { st = statSync(prev); } catch { }
-  const key = `${prev}|${st ? st.size : 0}|${st ? st.mtimeMs : 0}`;
-  const now = Date.now();
-  if (_prevScanCache && _prevScanCache.key === key && _prevScanCache.expiresAt > now) {
-    return _prevScanCache.promise;
+// wire-v2 S6a: upload a v2-session zip (produced by `?format=raw` download),
+// extract it to a temp dir, synthesize + stream it back as v1-shaped `\n---\n`
+// raw entries for ephemeral viewing, then delete the temp dir. Nothing is
+// written into LOG_DIR — view-only, parity with the legacy client-side `.jsonl`
+// upload. Raw `application/zip` body (no multipart); uses its own MAX_UPLOAD
+// cap, NOT deps.MAX_POST_BODY (which is ~10MB and would reject any real zip).
+function uploadLogZip(req, res) {
+  const contentLength = parseInt(req.headers['content-length'] || '0', 10);
+  if (contentLength > MAX_UPLOAD) {
+    res.writeHead(413, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'File too large', code: 'TOO_LARGE' }));
+    return;
   }
-  const promise = collectFilteredRawEntriesAsync(prev, predicate, opts);
-  _prevScanCache = { key, promise, expiresAt: now + PREV_SCAN_TTL_MS };
-  promise.catch(() => {
-    if (_prevScanCache && _prevScanCache.promise === promise) _prevScanCache = null;
-  });
-  return promise;
-}
-
-/**
- * Post-rotation teammate backfill. Resolves the previous segment of the
- * server's OWN live LOG_FILE (no client-supplied filenames — no traversal
- * surface) and streams NDJSON:
- *   line 1: { rotationContext, teammateNames }  (context; teammateNames merges
- *           the head sentinel's carry-forward with the in-process spawn
- *           registry — the sentinel may sit outside the client's load window)
- *   lines:  one backfill entry per line (teammate-like, renderable only)
- *   last:   { done: true, truncated, prevSegment }
- */
-async function prevSegmentTeammates(req, res, parsedUrl, isLocal, deps) {
-  res.writeHead(200, { 'Content-Type': 'application/x-ndjson' });
-  try {
-    const current = LOG_FILE;
-    const sentinel = readHeadRotationContext(current);
-    const names = new Map(sentinel?.teammateNames?.filter((p) => Array.isArray(p) && p[0]) || []);
-    for (const [prefix, name] of getAgentSpawnRegistrySnapshot()) names.set(prefix, name);
-    res.write(JSON.stringify({
-      rotationContext: sentinel ? { from: sentinel.from || null } : null,
-      teammateNames: [...names.entries()],
-    }) + '\n');
-    // No live file (workspace pre-select) or resume placeholder → context only.
-    if (!current || current.endsWith('_temp.jsonl')) {
-      res.end(JSON.stringify({ done: true, truncated: false, prevSegment: null }) + '\n');
+  let chunks = [];
+  let totalSize = 0;
+  let aborted = false;
+  // A large remote upload can reset mid-flight; without an 'error' listener the
+  // socket error would crash the process (unhandled 'error' event).
+  req.on('error', () => { aborted = true; chunks = []; });
+  req.on('data', (chunk) => {
+    if (aborted) return;
+    totalSize += chunk.length;
+    if (totalSize > MAX_UPLOAD) {
+      aborted = true;
+      res.writeHead(413, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'File too large', code: 'TOO_LARGE' }));
+      req.destroy();
       return;
     }
-    const instanceId = (deps && deps.instanceId) || null;
-    const prev = findPreviousSegment(current, _projectName, instanceId);
-    if (!prev) {
-      res.end(JSON.stringify({ done: true, truncated: false, prevSegment: null }) + '\n');
-      return;
+    chunks.push(chunk);
+  });
+  req.on('end', async () => {
+    if (aborted) return;
+    let tmpDir = null;
+    try {
+      tmpDir = mkdtempSync(join(tmpdir(), 'ccv-upload-'));
+      const buf = Buffer.concat(chunks);
+      chunks = []; // free the per-chunk copies; adm-zip holds `buf` from here
+      const sessionDir = extractV2Zip(buf, tmpDir);
+      res.writeHead(200, {
+        'Content-Type': 'application/octet-stream',
+        'Transfer-Encoding': 'chunked',
+      });
+      await streamRawEntriesAsync(sessionDir, (raw) => {
+        res.write(raw);
+        res.write('\n---\n');
+      });
+      res.end();
+    } catch (err) {
+      const status = err?.status || 500;
+      if (status >= 500) console.error('[api/upload-log-zip]', err);
+      if (!res.headersSent) {
+        const safeError = status >= 500 ? 'server_error' : (err?.message || 'error');
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: safeError, code: err?.code || 'unknown' }));
+      } else {
+        res.end();
+      }
+    } finally {
+      // Always reclaim the temp dir. The adapter has finished all reads by the
+      // time the await settles (cold v2 reads are bounded), so this is race-free
+      // even when the client disconnected mid-stream.
+      if (tmpDir) { try { rmSync(tmpDir, { recursive: true, force: true }); } catch {} }
     }
-    const { entries, truncated } = await collectPrevSegmentCached(prev, (entry) => (
-      !entry.inProgress && !entry.isHeartbeat && !entry.isCountTokens
-      && !entry.ccvRotationContext
-      && !(entry._deltaFormat && entry.mainAgent && !entry.teammate)
-      && !!entry.timestamp
-      && Array.isArray(entry.response?.body?.content) && entry.response.body.content.length > 0
-      && isTeammateLikeEntry(entry)
-    ), { rawPrefilter: teammateRawPrefilter });
-    for (const entry of entries) res.write(JSON.stringify(entry) + '\n');
-    res.end(JSON.stringify({ done: true, truncated, prevSegment: basename(prev) }) + '\n');
-  } catch (err) {
-    // Headers already sent — terminate the NDJSON stream with an error line.
-    try { res.end(JSON.stringify({ done: true, error: err?.message || 'internal error' }) + '\n'); } catch { }
-  }
+  });
 }
 
 export const logsRoutes = [
   { method: 'GET', match: 'exact', path: '/api/local-logs', handler: localLogs },
+  { method: 'GET', match: 'exact', path: '/api/wire-v2-convert', handler: getWireV2Convert },
+  { method: 'POST', match: 'exact', path: '/api/wire-v2-convert', handler: postWireV2Convert },
   { method: 'GET', match: 'exact', path: '/api/download-log', handler: downloadLog },
   { method: 'GET', match: 'exact', path: '/api/local-log', handler: localLog },
   { method: 'POST', match: 'exact', path: '/api/delete-logs', handler: deleteLogs },
-  { method: 'POST', match: 'exact', path: '/api/merge-logs', handler: mergeLogs },
-  { method: 'POST', match: 'exact', path: '/api/archive-logs', handler: archiveLogs },
-  { method: 'GET', match: 'exact', path: '/api/prev-segment-teammates', handler: prevSegmentTeammates },
+  { method: 'POST', match: 'exact', path: '/api/upload-log-zip', handler: uploadLogZip },
 ];

package/server/routes/preferences.js

@@ -58,7 +58,6 @@ function preferencesGet(req, res, parsedUrl, isLocal, deps) {
   prefs.logDir = LOG_DIR; // 始终返回当前运行时的日志目录
   // 日志设置出厂默认"继承"：键缺失（从未设置过）才注入；显式关闭持久化的是 null（键存在），不覆盖。
   // 虚拟默认 —— 仅注入回包不落盘（GET 不写文件），直接读 preferences.json 的代码看不到该默认。
-  if (!('resumeAutoChoice' in prefs)) prefs.resumeAutoChoice = 'continue';
   // home-friendly 展示形态：设了 CLAUDE_CONFIG_DIR 的用户看到真实路径，默认用户看到 "~/.claude"
   // join() 而非字符串拼接，避免 Windows 分隔符不匹配导致比较失败
   const _cDir = getClaudeConfigDir();
@@ -168,8 +167,6 @@ function preferencesPost(req, res, parsedUrl, isLocal, deps) {
       delete prefs.prefsByProject; // fork blob 绝不回显（与 GET 一致）
       stripImConfigs(prefs);
       prefs.logDir = LOG_DIR;
-      // 与 GET 一致：回显里补齐 resumeAutoChoice 虚拟默认（已在上方落盘，文件不含该默认值）
-      if (!('resumeAutoChoice' in prefs)) prefs.resumeAutoChoice = 'continue';
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(prefs));
     } catch (err) {

package/server/routes/project-meta.js

@@ -22,10 +22,9 @@ export function getInstallMethod({
   return 'npm';
 }
 
-function projectName(req, res, parsedUrl, isLocal, deps) {
+function projectName(req, res) {
   res.writeHead(200, { 'Content-Type': 'application/json' });
-  // instanceId (`--pid`) lets the client scope its session-pin requests + show 项目(id) in the title.
-  res.end(JSON.stringify({ projectName: _projectName || '', instanceId: (deps && deps.instanceId) || null }));
+  res.end(JSON.stringify({ projectName: _projectName || '' }));
 }
 
 function projectDir(req, res) {

package/server/routes/session-pin.js

@@ -1,7 +1,7 @@
 // Server-side "current session" pin — replaces the old per-browser localStorage pin so a
-// project's "仅展示当前会话" pointer is shared across every device hitting THIS ccv process,
-// and (with `--pid`) isolated between processes. View state only → no loopback gating.
-//   - GET  /api/session-pin                                  → { pinnedSessionId, instanceId }
+// project's current-session pointer is shared across every device hitting THIS ccv process.
+// View state only → no loopback gating.
+//   - GET  /api/session-pin                                  → { pinnedSessionId }
 //   - POST /api/session-pin {pinnedSessionId: string|null}   → persist + SSE-broadcast
 // `_logDir` is the live per-project dir ('' = no active project → GET null / POST no-op).
 import { _logDir } from '../interceptor.js';
@@ -13,9 +13,8 @@ function sendJson(res, code, obj) {
   res.end(JSON.stringify(obj));
 }
 
-function getHandler(req, res, parsedUrl, isLocal, deps) {
-  const instanceId = deps.instanceId || null;
-  sendJson(res, 200, { pinnedSessionId: readPin(_logDir, instanceId), instanceId });
+function getHandler(req, res) {
+  sendJson(res, 200, { pinnedSessionId: readPin(_logDir) });
 }
 
 function postHandler(req, res, parsedUrl, isLocal, deps) {
@@ -27,8 +26,8 @@ function postHandler(req, res, parsedUrl, isLocal, deps) {
     catch { return sendJson(res, 400, { error: 'Invalid JSON' }); }
     const raw = incoming.pinnedSessionId;
     const pinnedSessionId = (typeof raw === 'string' && raw) ? raw : null;
-    writePin(_logDir, deps.instanceId || null, pinnedSessionId);
-    // Broadcast to THIS process's SSE clients so every device on this instance stays in sync.
+    writePin(_logDir, pinnedSessionId);
+    // Broadcast to THIS process's SSE clients so every device stays in sync.
     sendEventToClients(deps.clients, 'session_pin', { pinnedSessionId });
     sendJson(res, 200, { ok: true, pinnedSessionId });
   });

package/server/routes/v2.js

@@ -0,0 +1,60 @@
+// Wire v3 routes (V3.S1+): on-demand single-entry detail for the metadata-row
+// request list. Registered unconditionally — harmless while CCV_WIRE_V3 is off
+// (nothing calls it), so the route itself needs no flag gate.
+import { join } from 'node:path';
+import { LOG_DIR } from '../../findcc.js';
+import { validateLogPath } from '../lib/log-management.js';
+import { resolveSessionDirName } from '../lib/v2/session-select.js';
+import { readV2SingleEntry } from '../lib/v2/adapter.js';
+import { sseHead, sseWrite, wireEnd } from '../lib/wire-compress.js';
+
+/**
+ * GET /api/v2-entry?file=v2:<project>/<dirToken>&seq=N[&sid=<uuid>]
+ * dirToken is normally the session dir basename (`<ts>_<uuid>`); a bare UUID
+ * (the client only holds `_seqEpoch="v2:<uuid>"`) is resolved to the basename
+ * BEFORE validateLogPath — validation expects an existing directory path.
+ * `sid` disambiguates teammate rows: the fold runs over the leader dir, the
+ * target is keyed (sid, seq); omitted = match seq in any folded session.
+ */
+async function v2Entry(req, res, parsedUrl) {
+  const file = parsedUrl.searchParams.get('file') || '';
+  const seq = parseInt(parsedUrl.searchParams.get('seq'), 10);
+  const sid = parsedUrl.searchParams.get('sid') || null;
+  const m = /^v2:([^/]+)\/([^/]+)$/.exec(file);
+  if (!m || !Number.isInteger(seq) || seq < 0) {
+    res.writeHead(400, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: 'expected file=v2:<project>/<session>&seq=<n>' }));
+    return;
+  }
+  try {
+    // UUID → dir-basename resolution first (rename/-c adoption safe), then the
+    // same path validation every other v2 ref goes through.
+    const [, project, dirToken] = m;
+    const resolved = resolveSessionDirName(join(LOG_DIR, project), dirToken) || dirToken;
+    const sessionDir = validateLogPath(LOG_DIR, `v2:${project}/${resolved}`);
+    const result = await readV2SingleEntry(sessionDir, { seq, sessionId: sid });
+    if (!result) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'entry not found' }));
+      return;
+    }
+    // Whole-stream JSON (like /api/requests): compress without per-event flush.
+    sseHead(req, res, 200, { 'Content-Type': 'application/json' }, { flush: false });
+    // slots are raw JSON strings — compose without re-parse/re-stringify.
+    sseWrite(res, `{"entry":${result.entry},"prevMain":${result.prevMain ?? 'null'}}`);
+    wireEnd(res);
+  } catch (err) {
+    console.error('[v2-entry]', file, err && err.stack || err);
+    if (!res.headersSent) {
+      const status = err.code === 'NOT_FOUND' ? 404 : err.code === 'ACCESS_DENIED' ? 403 : 500;
+      res.writeHead(status, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message }));
+    } else {
+      wireEnd(res);
+    }
+  }
+}
+
+export const v2Routes = [
+  { method: 'GET', match: 'exact', path: '/api/v2-entry', handler: v2Entry },
+];