cc-viewer 1.6.265 → 1.6.267

package/dist/index.html

@@ -19,7 +19,7 @@
       if (pick) document.documentElement.setAttribute('data-theme', pick);
     } catch {}
   </script>
-  <script type="module" crossorigin src="/assets/index-BOxeMjZZ.js"></script>
+  <script type="module" crossorigin src="/assets/index-DA3EDksT.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-BG1SvzuN.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-8NDhydlF.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-BB4hhpxM.js">

package/i18n.js

@@ -2200,24 +2200,24 @@ const i18nData = {
     "uk": "Виберіть послідовні файли логів"
   },
   "ui.mergeTooLarge": {
-    "zh": "选中的日志文件总大小超过 500MB",
-    "en": "Selected log files exceed 500MB",
-    "zh-TW": "選中的日誌檔案總大小超過 500MB",
-    "ko": "선택한 로그 파일의 총 크기가 500MB를 초과합니다",
-    "ja": "選択したログファイルの合計サイズが 500MB を超えています",
-    "de": "Ausgewählte Log-Dateien überschreiten 500MB",
-    "es": "Los archivos de log seleccionados superan los 500MB",
-    "fr": "Les fichiers de log sélectionnés dépassent 500 Mo",
-    "it": "I file di log selezionati superano i 500MB",
-    "da": "Valgte logfiler overstiger 500MB",
-    "pl": "Wybrane pliki logów przekraczają 500MB",
-    "ru": "Выбранные файлы логов превышают 500МБ",
-    "ar": "ملفات السجلات المحددة تتجاوز 500 ميجابايت",
-    "no": "Valgte loggfiler overstiger 500MB",
-    "pt-BR": "Arquivos de log selecionados excedem 500MB",
-    "th": "ไฟล์บันทึกที่เลือกมีขนาดรวมเกิน 500MB",
-    "tr": "Seçilen log dosyaları 500MB'ı aşıyor",
-    "uk": "Вибрані файли логів перевищують 500МБ"
+    "zh": "选中的日志文件总大小超过 400MB",
+    "en": "Selected log files exceed 400MB",
+    "zh-TW": "選中的日誌檔案總大小超過 400MB",
+    "ko": "선택한 로그 파일의 총 크기가 400MB를 초과합니다",
+    "ja": "選択したログファイルの合計サイズが 400MB を超えています",
+    "de": "Ausgewählte Log-Dateien überschreiten 400MB",
+    "es": "Los archivos de log seleccionados superan los 400MB",
+    "fr": "Les fichiers de log sélectionnés dépassent 400 Mo",
+    "it": "I file di log selezionati superano i 400MB",
+    "da": "Valgte logfiler overstiger 400MB",
+    "pl": "Wybrane pliki logów przekraczają 400MB",
+    "ru": "Выбранные файлы логов превышают 400МБ",
+    "ar": "ملفات السجلات المحددة تتجاوز 400 ميجابايت",
+    "no": "Valgte loggfiler overstiger 400MB",
+    "pt-BR": "Arquivos de log selecionados excedem 400MB",
+    "th": "ไฟล์บันทึกที่เลือกมีขนาดรวมเกิน 400MB",
+    "tr": "Seçilen log dosyaları 400MB'ı aşıyor",
+    "uk": "Вибрані файли логів перевищують 400МБ"
   },
   "ui.mergeSuccess": {
     "zh": "日志合并成功",

package/lib/jsonl-archive.js

@@ -0,0 +1,181 @@
+import {
+  existsSync, statSync, lstatSync, mkdirSync, renameSync, unlinkSync,
+  writeFileSync, readFileSync, readdirSync, rmSync,
+} from 'node:fs';
+import { join, basename } from 'node:path';
+import { tmpdir } from 'node:os';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import { validateZipEntries } from './zip-safety.js';
+
+const require = createRequire(import.meta.url);
+const AdmZip = require('adm-zip');
+
+const CACHE_ROOT_NAME = 'ccv-extract';
+const RENAME_RETRY = 3;
+const RENAME_DELAY_MS = 50;
+const CACHE_TTL_MS = 7 * 24 * 3600 * 1000;
+// 与 lib/log-management.js 的 MAX_MERGE_SIZE 对齐：merge 上限 400MB，归档 / 读回 zip
+// 必须容纳这一规模，否则自家产物会被 zip-safety 默认 50MB 阈值拦住造成永久不可读。
+const ARCHIVE_MAX_BYTES = 400 * 1024 * 1024;
+
+function syncSleep(ms) {
+  // Atomics.wait 在主线程上真睡眠（不像 busy-wait 占满 CPU 或阻塞 event-loop heuristics）
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function renameWithRetry(from, to) {
+  let lastErr;
+  for (let i = 0; i < RENAME_RETRY; i++) {
+    try { renameSync(from, to); return; }
+    catch (err) {
+      lastErr = err;
+      if (i < RENAME_RETRY - 1 && (err.code === 'EBUSY' || err.code === 'EPERM' || err.code === 'EACCES')) {
+        syncSleep(RENAME_DELAY_MS);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastErr;
+}
+
+export function getExtractCacheRoot() {
+  return join(tmpdir(), CACHE_ROOT_NAME);
+}
+
+function pathHash(absPath) {
+  return createHash('sha1').update(absPath).digest('hex').slice(0, 16);
+}
+
+export function archiveJsonl(absJsonlPath) {
+  if (!absJsonlPath.endsWith('.jsonl')) return { ok: false, error: 'Not a .jsonl file' };
+  if (!existsSync(absJsonlPath)) return { ok: false, error: 'Source file not found' };
+
+  // 拒绝 symlink 源：避免归档目标外文件并删除链接造成信息错乱
+  try {
+    const lst = lstatSync(absJsonlPath);
+    if (!lst.isFile()) return { ok: false, error: 'Source is not a regular file' };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+
+  const zipPath = absJsonlPath + '.zip';
+  if (existsSync(zipPath)) {
+    return { ok: false, skipped: 'target-exists', error: 'Target .zip already exists' };
+  }
+
+  const tmpPath = `${zipPath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const zip = new AdmZip();
+    zip.addLocalFile(absJsonlPath);
+    for (const e of zip.getEntries()) {
+      if (e.header) e.header.flags = (e.header.flags || 0) | 0x800;
+    }
+    zip.writeZip(tmpPath);
+
+    if (!existsSync(tmpPath) || statSync(tmpPath).size === 0) {
+      throw new Error('Generated zip is empty');
+    }
+
+    renameWithRetry(tmpPath, zipPath);
+    try { unlinkSync(absJsonlPath); }
+    catch (err) {
+      // 罕见：zip 已 rename 成功但原 .jsonl 删除失败（AV 扫描 / Windows 句柄占用 / 权限）。
+      // 此时两份共存，下次列表 regex 会同时显示，再次归档会撞"Target exists"死锁。
+      // 回滚策略：删掉刚 rename 出来的 zip，原文件原位保留，调用方收到 failed → 用户可重试。
+      try { unlinkSync(zipPath); } catch { /* zip rollback 失败也容忍：极端边界 */ }
+      return { ok: false, error: `archived but failed to delete source: ${err.message}` };
+    }
+    return { ok: true, zipPath };
+  } catch (err) {
+    try { if (existsSync(tmpPath)) unlinkSync(tmpPath); } catch { /* ignore */ }
+    return { ok: false, error: err.message };
+  }
+}
+
+export function resolveJsonlPath(absPath) {
+  if (typeof absPath !== 'string') return absPath;
+  if (absPath.endsWith('.jsonl') && existsSync(absPath)) return absPath;
+
+  let zipPath = null;
+  if (absPath.endsWith('.jsonl.zip')) zipPath = absPath;
+  else if (absPath.endsWith('.jsonl')) {
+    const candidate = absPath + '.zip';
+    if (existsSync(candidate)) zipPath = candidate;
+  }
+
+  if (!zipPath || !existsSync(zipPath)) return absPath;
+  return extractZipSync(zipPath);
+}
+
+function extractZipSync(zipPath) {
+  const cacheKey = pathHash(zipPath);
+  const cacheDir = join(getExtractCacheRoot(), cacheKey);
+  const targetName = basename(zipPath, '.zip');
+  const tmpFile = join(cacheDir, targetName);
+  const sidecar = join(cacheDir, '.meta.json');
+
+  const zipStat = statSync(zipPath);
+  const expectedMeta = { srcMtimeMs: zipStat.mtimeMs, srcSize: zipStat.size };
+
+  if (existsSync(tmpFile) && existsSync(sidecar)) {
+    try {
+      const meta = JSON.parse(readFileSync(sidecar, 'utf-8'));
+      if (meta.srcMtimeMs === expectedMeta.srcMtimeMs && meta.srcSize === expectedMeta.srcSize) {
+        return tmpFile;
+      }
+    } catch { /* fall through to re-extract */ }
+  }
+
+  mkdirSync(cacheDir, { recursive: true });
+  const zip = new AdmZip(zipPath);
+  const entries = zip.getEntries();
+
+  validateZipEntries(entries, cacheDir, {
+    maxEntries: 5,
+    requireExtension: '.jsonl',
+    maxPerFile: ARCHIVE_MAX_BYTES,
+    maxTotal: ARCHIVE_MAX_BYTES,
+  });
+
+  const fileEntry = entries.find(e => !e.isDirectory && e.entryName.toLowerCase().endsWith('.jsonl'));
+  if (!fileEntry) {
+    throw Object.assign(new Error('No .jsonl entry found in zip'), { code: 'ZIP_UNSAFE' });
+  }
+
+  const partial = `${tmpFile}.partial.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    writeFileSync(partial, fileEntry.getData());
+    renameWithRetry(partial, tmpFile);
+    writeFileSync(sidecar, JSON.stringify(expectedMeta));
+  } catch (err) {
+    try { if (existsSync(partial)) unlinkSync(partial); } catch { /* ignore */ }
+    throw err;
+  }
+
+  return tmpFile;
+}
+
+export function cleanupExtractCache() {
+  try {
+    const root = getExtractCacheRoot();
+    if (!existsSync(root)) return;
+    const now = Date.now();
+    for (const ent of readdirSync(root, { withFileTypes: true })) {
+      if (!ent.isDirectory()) continue;
+      const subDir = join(root, ent.name);
+      try {
+        const stat = statSync(subDir);
+        // 用 mtimeMs（解压完成时间）而非 atimeMs：macOS / Linux 默认 noatime/relatime
+        // 下 atime 几乎不更新，会让 cache 永不过期或被错误提前回收。mtime 由 mkdirSync /
+        // 重新解压 rename 触发，能准确反映"最近一次解压时间"。
+        if (now - stat.mtimeMs > CACHE_TTL_MS) {
+          rmSync(subDir, { recursive: true, force: true });
+        }
+      } catch { /* tolerate one bad entry */ }
+    }
+  } catch (err) {
+    console.warn('[ccv-extract] cleanup failed:', err.message);
+  }
+}

package/lib/log-management.js

@@ -3,6 +3,7 @@ import { renameSyncWithRetry } from './file-api.js';
 import { join } from 'node:path';
 import { reconstructEntries } from './delta-reconstructor.js';
 import { streamReconstructedEntries } from './log-stream.js';
+import { archiveJsonl, resolveJsonlPath } from './jsonl-archive.js';
 
 /**
  * Validate that a resolved file path is contained within logDir.
@@ -28,6 +29,10 @@ export function validateLogPath(logDir, file) {
   return realPath;
 }
 
+function isLogFileName(name) {
+  return name.endsWith('.jsonl') || name.endsWith('.jsonl.zip');
+}
+
 /**
  * List local log files grouped by project.
  * @param {string} logDir - base log directory
@@ -43,7 +48,7 @@ export function listLocalLogs(logDir, currentProjectName) {
       const project = entry.name;
       const projectDir = join(logDir, project);
       const files = readdirSync(projectDir)
-        .filter(f => f.endsWith('.jsonl'))
+        .filter(isLogFileName)
         .sort()
         .reverse();
       // 从项目统计缓存中读取 per-file 数据，避免逐文件扫描
@@ -55,15 +60,18 @@ export function listLocalLogs(logDir, currentProjectName) {
         }
       } catch { }
       for (const f of files) {
-        const match = f.match(/^(.+?)_(\d{8}_\d{6})\.jsonl$/);
+        const match = f.match(/^(.+?)_(\d{8}_\d{6})\.jsonl(\.zip)?$/);
         if (!match) continue;
         const ts = match[2];
+        const archived = !!match[3];
         const filePath = join(projectDir, f);
         const size = statSync(filePath).size;
         if (size === 0) continue; // 跳过空文件
-        const turns = statsFiles?.[f]?.summary?.sessionCount || 0;
+        // 归档前的统计缓存 key 是 `.jsonl`；归档后切到 `.jsonl.zip`；两种都尝试
+        const stats = statsFiles?.[f] || (archived ? statsFiles?.[f.slice(0, -4)] : null);
+        const turns = stats?.summary?.sessionCount || 0;
         if (!grouped[project]) grouped[project] = [];
-        grouped[project].push({ file: `${project}/${f}`, timestamp: ts, size, turns, preview: statsFiles?.[f]?.preview || [] });
+        grouped[project].push({ file: `${project}/${f}`, timestamp: ts, size, turns, preview: stats?.preview || [], archived });
       }
     }
   }
@@ -78,7 +86,7 @@ export function listLocalLogs(logDir, currentProjectName) {
  */
 export function readLocalLog(logDir, file) {
   validateLogPath(logDir, file);
-  const filePath = join(logDir, file);
+  const filePath = resolveJsonlPath(join(logDir, file));
   const content = readFileSync(filePath, 'utf-8');
   const parsed = content.split('\n---\n').filter(line => line.trim()).map(entry => {
     try { return JSON.parse(entry); } catch { return null; }
@@ -101,7 +109,7 @@ export function readLocalLog(logDir, file) {
 export function deleteLogFiles(logDir, files) {
   const results = [];
   for (const file of files) {
-    if (!file || file.includes('..') || !file.endsWith('.jsonl')) {
+    if (!file || file.includes('..') || !isLogFileName(file)) {
       results.push({ file, error: 'Invalid file name' });
       continue;
     }
@@ -138,6 +146,16 @@ export function mergeLogFiles(logDir, files) {
     err.code = 'INVALID_INPUT';
     throw err;
   }
+  // 拒绝归档文件参与合并：mergeLogFiles 会以 files[0] 路径写入 plain jsonl 内容，若该路径
+  // 是 .jsonl.zip 会把 zip 文件覆写成裸文本破坏归档；且合并产物语义上应该是可继续追加的
+  // 活动文件，与"归档=只读快照"语义冲突。前端 UI 已 disabled，此处后端兜底。
+  for (const f of files) {
+    if (typeof f === 'string' && f.endsWith('.jsonl.zip')) {
+      const err = new Error('Cannot merge archived (.jsonl.zip) files');
+      err.code = 'INVALID_INPUT';
+      throw err;
+    }
+  }
   // 校验所有文件属于同一 project
   // 兼容 Win backslash：files 内部可能是 `project\log.json`，按两种 sep 都切才能拿 project 段。
   const projects = new Set(files.map(f => f.split(/[\\/]/)[0]));
@@ -159,14 +177,14 @@ export function mergeLogFiles(logDir, files) {
       throw err;
     }
   }
-  // 校验合并后总大小不超过 300MB
-  const MAX_MERGE_SIZE = 300 * 1024 * 1024;
+  // 校验合并后总大小不超过 400MB
+  const MAX_MERGE_SIZE = 400 * 1024 * 1024;
   let totalSize = 0;
   for (const f of files) {
     totalSize += statSync(join(logDir, f)).size;
   }
   if (totalSize > MAX_MERGE_SIZE) {
-    const err = new Error(`Merged size (${(totalSize / 1024 / 1024).toFixed(1)}MB) exceeds 300MB limit`);
+    const err = new Error(`Merged size (${(totalSize / 1024 / 1024).toFixed(1)}MB) exceeds ${MAX_MERGE_SIZE / 1024 / 1024}MB limit`);
     err.code = 'INVALID_INPUT';
     throw err;
   }
@@ -198,3 +216,104 @@ export function mergeLogFiles(logDir, files) {
   }
   return targetFile;
 }
+
+function migrateStatsCacheKey(projectDir, projectName, oldFileName, newFileName) {
+  const statsFile = join(projectDir, `${projectName}.json`);
+  if (!existsSync(statsFile)) return;
+  try {
+    const stats = JSON.parse(readFileSync(statsFile, 'utf-8'));
+    if (stats?.files?.[oldFileName]) {
+      const entry = stats.files[oldFileName];
+      // 同步用归档后 .zip 的 size / mtime 覆写 entry，避免 stats-worker 下次扫描时
+      // 因 size/mtime 不匹配判定 cache stale 触发整文件重解析（大 jsonl 数秒 CPU）。
+      try {
+        const zipStat = statSync(join(projectDir, newFileName));
+        entry.size = zipStat.size;
+        entry.lastModified = zipStat.mtime.toISOString();
+      } catch { /* zip 不可 stat 时不更新，让 stats 自然重建 */ }
+      stats.files[newFileName] = entry;
+      delete stats.files[oldFileName];
+      writeFileSync(statsFile, JSON.stringify(stats, null, 2));
+    }
+  } catch { /* tolerant */ }
+}
+
+/**
+ * 压缩归档多个 .jsonl 文件。每个 project 的最新文件（按文件名 desc 排序后的 logs[0]）
+ * 被拒绝，复用 mergeLogFiles 的"最新不允许"语义。
+ * @param {string} logDir
+ * @param {string[]} files - 形如 "project/<name>.jsonl"
+ * @returns {{ archived: string[], skipped: Array<{file:string,reason:string}>, failed: Array<{file:string,reason:string}> }}
+ */
+export function archiveLogFiles(logDir, files) {
+  const archived = [];
+  const skipped = [];
+  const failed = [];
+
+  // 按 project 分组以判定最新文件
+  const byProject = new Map();
+  for (const f of files) {
+    if (!f || typeof f !== 'string' || f.includes('..') || !f.endsWith('.jsonl')) {
+      failed.push({ file: f, reason: 'Invalid file name' });
+      continue;
+    }
+    const parts = f.split(/[\\/]/);
+    if (parts.length < 2) {
+      failed.push({ file: f, reason: 'Invalid file path' });
+      continue;
+    }
+    const project = parts[0];
+    if (!byProject.has(project)) byProject.set(project, []);
+    byProject.get(project).push(f);
+  }
+
+  let realLogDir;
+  try { realLogDir = realpathSync(logDir); }
+  catch (err) { return { archived, skipped, failed: files.map(f => ({ file: f, reason: err.message })) }; }
+
+  for (const [project, projectFiles] of byProject) {
+    const projectDir = join(logDir, project);
+    let latest = null;
+    try {
+      const projectEntries = readdirSync(projectDir)
+        .filter(isLogFileName)
+        .sort()
+        .reverse();
+      latest = projectEntries[0] || null;
+    } catch { /* directory missing => downstream calls will fail */ }
+
+    for (const f of projectFiles) {
+      const fileName = f.split(/[\\/]/).slice(1).join('/');
+      if (latest && fileName === latest) {
+        skipped.push({ file: f, reason: 'latest-not-allowed' });
+        continue;
+      }
+      const filePath = join(logDir, f);
+      let realPath;
+      try {
+        if (!existsSync(filePath)) { failed.push({ file: f, reason: 'Not found' }); continue; }
+        realPath = realpathSync(filePath);
+        if (!realPath.startsWith(realLogDir)) {
+          failed.push({ file: f, reason: 'Access denied' });
+          continue;
+        }
+      } catch (err) {
+        failed.push({ file: f, reason: err.message });
+        continue;
+      }
+
+      const result = archiveJsonl(realPath);
+      if (result.ok) {
+        archived.push(f);
+        migrateStatsCacheKey(projectDir, project, fileName, fileName + '.zip');
+      } else if (result.skipped) {
+        skipped.push({ file: f, reason: result.skipped });
+      } else {
+        // archiveJsonl 内部已在 unlink 失败时回滚 zip，此处 fail 即原状态完整保留，用户可重试
+        failed.push({ file: f, reason: result.error || 'archive failed' });
+      }
+    }
+  }
+
+  return { archived, skipped, failed };
+}

package/lib/log-stream.js

@@ -12,6 +12,7 @@
 
 import { existsSync, statSync, openSync, readSync, closeSync } from 'node:fs';
 import { isCheckpointEntry, isDeltaEntry, reconstructSegment } from './delta-reconstructor.js';
+import { resolveJsonlPath } from './jsonl-archive.js';
 
 const READ_CHUNK_SIZE = 1024 * 1024; // 1MB
 const SEPARATOR = '\n---\n';
@@ -21,6 +22,7 @@ const SEPARATOR = '\n---\n';
  * 内存 = 1MB buffer + pending。
  */
 function* iterateRawEntries(filePath) {
+  filePath = resolveJsonlPath(filePath);
   const fileSize = statSync(filePath).size;
   if (fileSize === 0) return;
 
@@ -59,6 +61,7 @@ function* iterateRawEntries(filePath) {
  * 用于 SSE load_start 的 total 字段（进度显示）。
  */
 export function countLogEntries(filePath) {
+  filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return 0;
   let count = 0;
   for (const _ of iterateRawEntries(filePath)) { count++; }
@@ -102,6 +105,7 @@ function isSegmentBoundary(entry) {
 // ============================================================================
 
 export function streamReconstructedEntries(filePath, onSegment, opts = {}) {
+  filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return 0;
   const stat = statSync(filePath);
   if (stat.size === 0) return 0;
@@ -178,6 +182,7 @@ export function streamReconstructedEntries(filePath, onSegment, opts = {}) {
  * @returns {Promise<{sentCount: number, totalCount: number}>}
  */
 export async function streamRawEntriesAsync(filePath, onRawEntry, opts = {}) {
+  filePath = resolveJsonlPath(filePath);
   const empty = { sentCount: 0, totalCount: 0 };
   if (!existsSync(filePath)) { if (opts.onReady) opts.onReady({ totalCount: 0 }); return empty; }
   const stat = statSync(filePath);
@@ -266,6 +271,7 @@ export async function streamRawEntriesAsync(filePath, onRawEntry, opts = {}) {
  * @returns {{ entries: string[], hasMore: boolean, oldestTimestamp: string, count: number }}
  */
 export function readPagedEntries(filePath, { before, limit }) {
+  filePath = resolveJsonlPath(filePath);
   if (!existsSync(filePath)) return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };
   const stat = statSync(filePath);
   if (stat.size === 0) return { entries: [], hasMore: false, oldestTimestamp: '', count: 0 };

package/lib/log-watcher.js

@@ -4,6 +4,7 @@ import { buildContextWindowEvent, getContextSizeForModel } from './context-watch
 import { reconstructEntries, createIncrementalReconstructor } from './delta-reconstructor.js';
 import { countLogEntries, streamReconstructedEntries } from './log-stream.js';
 import { enrichEntry } from './enrich-plan-input.js';
+import { resolveJsonlPath } from './jsonl-archive.js';
 
 // 跟踪所有被 watch 的日志文件
 const watchedFiles = new Map();
@@ -14,6 +15,9 @@ const watchedFiles = new Map();
  * @returns {Array} parsed and deduplicated entries
  */
 export function readLogFile(logFile) {
+  // 透明支持归档后的 .jsonl.zip。active log（被 watchLogFile 追加写入的文件）不会被归档
+  // （archive 拒绝最新文件），watchLogFile 内部的 openSync/readSync 因此无需走 resolveJsonlPath。
+  logFile = resolveJsonlPath(logFile);
   if (!existsSync(logFile)) {
     return [];
   }

package/lib/stats-worker.js

@@ -2,6 +2,7 @@
 import { parentPort } from 'node:worker_threads';
 import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { join, basename } from 'node:path';
+import { resolveJsonlPath } from './jsonl-archive.js';
 
 // 统计 schema 版本号，新增统计字段时递增，强制旧缓存失效重新解析
 const STATS_VERSION = 8;
@@ -98,7 +99,8 @@ function parseJsonlFile(filePath) {
   let lastCollectedSig = '';  // 上次收集的 prompt 签名，用于去重同轮重复请求
 
   try {
-    const content = readFileSync(filePath, 'utf-8');
+    const realPath = resolveJsonlPath(filePath);
+    const content = readFileSync(realPath, 'utf-8');
     if (!content.trim()) return { models, summary: { requestCount: 0, sessionCount: 0, turnCount: 0, input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 }, preview: [] };
 
     const entries = content.split('\n---\n').filter(p => p.trim());
@@ -234,7 +236,7 @@ function generateProjectStats(projectDir, projectName, onlyFile) {
   let jsonlFiles;
   try {
     jsonlFiles = readdirSync(projectDir)
-      .filter(f => f.endsWith('.jsonl') && !f.endsWith('_temp.jsonl'))
+      .filter(f => (f.endsWith('.jsonl') || f.endsWith('.jsonl.zip')) && !f.endsWith('_temp.jsonl'))
       .sort();
   } catch {
     return;

package/lib/zip-safety.js

@@ -0,0 +1,68 @@
+import { resolve, sep, posix } from 'node:path';
+
+const MAX_PER_FILE_DEFAULT = 50 * 1024 * 1024;
+const MAX_TOTAL_DEFAULT = 200 * 1024 * 1024;
+
+function isSymlinkEntry(entry) {
+  const unixMode = (entry.attr >>> 16) & 0xffff;
+  return (unixMode & 0o170000) === 0o120000;
+}
+
+function toPosix(name) {
+  return name.split('\\').join('/');
+}
+
+export function isSafeEntryName(name) {
+  if (!name || typeof name !== 'string') return false;
+  if (name.includes('\x00')) return false;
+  const slashed = toPosix(name);
+  if (slashed.startsWith('/')) return false;
+  if (/^[A-Za-z]:/.test(slashed)) return false;
+  const norm = posix.normalize(slashed);
+  if (norm === '..' || norm.startsWith('../') || norm.includes('/../')) return false;
+  return true;
+}
+
+export function isWithinTargetDir(entryName, targetDir) {
+  const target = resolve(targetDir);
+  const dest = resolve(target, toPosix(entryName));
+  return dest === target || dest.startsWith(target + sep);
+}
+
+export function validateZipEntries(entries, targetDir, opts = {}) {
+  const {
+    maxEntries = Infinity,
+    maxPerFile = MAX_PER_FILE_DEFAULT,
+    maxTotal = MAX_TOTAL_DEFAULT,
+    requireExtension = null,
+  } = opts;
+  let fileCount = 0;
+  let totalSize = 0;
+  for (const e of entries) {
+    if (e.isDirectory) continue;
+    fileCount++;
+    if (fileCount > maxEntries) {
+      throw Object.assign(new Error('Too many entries in zip'), { code: 'ZIP_TOO_MANY' });
+    }
+    if (isSymlinkEntry(e)) {
+      throw Object.assign(new Error('Symlinks not allowed in zip'), { code: 'ZIP_UNSAFE' });
+    }
+    if (!isSafeEntryName(e.entryName)) {
+      throw Object.assign(new Error(`Unsafe zip entry name: ${e.entryName}`), { code: 'ZIP_UNSAFE' });
+    }
+    if (!isWithinTargetDir(e.entryName, targetDir)) {
+      throw Object.assign(new Error(`Zip entry escapes target dir: ${e.entryName}`), { code: 'ZIP_UNSAFE' });
+    }
+    if (requireExtension && !e.entryName.toLowerCase().endsWith(requireExtension.toLowerCase())) {
+      throw Object.assign(new Error(`Disallowed extension: ${e.entryName}`), { code: 'ZIP_UNSAFE' });
+    }
+    const sizeRaw = e.header?.size || 0;
+    if (sizeRaw > maxPerFile) {
+      throw Object.assign(new Error('File too large in archive'), { code: 'ZIP_BOMB' });
+    }
+    totalSize += sizeRaw;
+    if (totalSize > maxTotal) {
+      throw Object.assign(new Error('Archive expands too large'), { code: 'ZIP_BOMB' });
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.265",
+  "version": "1.6.267",
   "description": "Claude Code Logger visualization management tool",
   "license": "MIT",
   "main": "server.js",