cc-viewer 1.6.249 → 1.6.251

package/dist/index.html

@@ -6,7 +6,7 @@
   <title>Claude Code Viewer</title>
   <link rel="icon" href="/favicon.ico?v=1">
   <link rel="shortcut icon" href="/favicon.ico?v=1">
-  <script type="module" crossorigin src="/assets/index-etQ0_qi5.js"></script>
+  <script type="module" crossorigin src="/assets/index-nCqmU6FA.js"></script>
   <link rel="modulepreload" crossorigin href="/assets/vendor-antd-BeN8xqGk.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-codemirror-2nbmPewy.js">
   <link rel="modulepreload" crossorigin href="/assets/vendor-mdxeditor-C7DYEBoH.js">

package/interceptor.js

@@ -237,17 +237,32 @@ function resolveResumeChoice(choice) {
 }
 
 // Delta storage: 增量存储开关和状态（默认开启，设置 CCV_DISABLE_DELTA=1 关闭）
-// 注意：delta 计算依赖 mainAgent 请求串行（Claude CLI 保证），不做并发互斥
+// 注意：delta 计算原本依赖 mainAgent 请求串行假设。实证发现 teammate 终止 / 多 SSE 通道
+// 注入等情况会让两条 mainAgent 请求 30ms 内连续到达（前一条流式响应未完成时后一条已发起），
+// 导致仅在 completed 时更新 _lastMessagesCount/_lastTailFp 出现状态滞后 → Plan C 漏检。
 const _deltaStorageEnabled = process.env.CCV_DISABLE_DELTA !== '1';
 // In-place last-msg replace 检测开关（默认开启，设置 CCV_DISABLE_TAIL_FP_CHECKPOINT=1 关闭）。
 // 关闭后回退到旧行为（仅按长度算 delta，遇到末位原地替换会丢失"末位换内容"信息）。
 const _tailFpCheckEnabled = process.env.CCV_DISABLE_TAIL_FP_CHECKPOINT !== '1';
-let _lastMessagesCount = 0;     // 上一次 mainAgent 写入的完整 messages 数量
-let _lastTailFp = '';           // 上一次 mainAgent 末位 message 的指纹（用于 in-place replace 检测）
+// 这两个变量代表"截至本次请求开始前的最新已知态"。请求开始处理时即同步更新（eager），
+// 不再等到 _commitDeltaState（completed 时执行）。Plan C 检测使用进入函数前的快照。
+// 异常分支（请求失败 / 服务端不发送）不会回滚——下一个成功请求覆盖即可，状态不会永久错位。
+// 命名说明：变量名保留 `_last` 前缀（历史命名），但语义已由"上次 commit 后"变为"上次见到的最新态"。
+// 三路并发场景下，连续 3 个请求若 length 非单调（如 257→259→258），_lastMessagesCount 会跟随
+// 最新一次 startRequest，可能让早到的更大值被覆盖；这种情况 Plan C 走 length 不等支路最终
+// 命中 needsCheckpoint 写完整快照，client 拿到正确数据，不破坏正确性。
+let _lastMessagesCount = 0;     // 截至最近一次 startRequest 的完整 messages 数量（eager-updated）
+let _lastTailFp = '';           // 截至最近一次 startRequest 的末位 message 指纹（eager-updated）
 let _mainAgentDeltaCount = 0;   // mainAgent 请求计数器（用于触发定期 checkpoint）
 const CHECKPOINT_INTERVAL = 10; // 每 N 条 mainAgent 请求写一个 checkpoint
 
-/** Delta storage: completed 写入成功后更新状态 */
+/**
+ * Delta storage: completed 写入成功后更新状态。
+ * eager-update 已在请求开始时把 _lastMessagesCount/_lastTailFp 推到本次值，本函数对同
+ * originalLength 的 commit 实际是 no-op（`originalLength > _lastMessagesCount` 判等返回 false）。
+ * 保留为防御层：处理 eager 块未跑到的早期 return / throw（例如 _deltaStorageEnabled=false
+ * 或 messages 不是数组时不会进入 eager 块），让 commit 路径仍能在 completed 时把状态推上去。
+ */
 function _commitDeltaState(originalLength, originalTailFp) {
   if (_deltaStorageEnabled && originalLength > 0) {
     _lastMessagesCount = originalLength;
@@ -615,23 +630,35 @@ export function setupInterceptor() {
       _deltaOriginalTailFp = messages.length > 0 ? fingerprintMsg(messages[messages.length - 1]) : '';
       _mainAgentDeltaCount++;
 
+      // 并发竞态修复（详见模块顶部注释 + history.md Unreleased 段 fix(interceptor) 条目）：
+      // snapshot 上一请求处理时的 count/fp 给 Plan C 用，然后 eager 把模块级状态推到本次值
+      // （不等 _commitDeltaState）。BUG 来源：teammate 终止快速串行让 mainAgent 30ms 内连续
+      // firing，旧 commit 时序使 Plan C 拿陈旧 prev 漏检 → client doubled-history。
+      const _prevMessagesCount = _lastMessagesCount;
+      const _prevTailFp = _lastTailFp;
+      if (_deltaOriginalMessagesLength > 0) {
+        _lastMessagesCount = _deltaOriginalMessagesLength;
+        if (_deltaOriginalTailFp !== '') _lastTailFp = _deltaOriginalTailFp;
+      }
+
       // In-place last-msg replace 检测：messages.length 不变但末位 fp 不同。
       // 触发场景：CLI 在 mainAgent 末位"原地替换"user msg（SUGGESTION MODE → 用户真实输入；
-      // synthetic recap 通道注入；等），wire 上长度未变内容变了。旧逻辑 messages.slice(_lastMessagesCount)
-      // 算出 delta=[]，丢失了"末位换内容"信息 → 客户端重建拿到错误的"前态末位"。
+      // synthetic recap 通道注入；teammate 终止快速串行 → SUGGESTION MODE 多次替换；等），
+      // wire 上长度未变内容变了。旧逻辑 messages.slice(_lastMessagesCount) 算出 delta=[]，
+      // 丢失了"末位换内容"信息 → 客户端重建拿到错误的"前态末位"。
       // 检测命中即强制写 checkpoint，让客户端拿到完整 wire 真实内容。
       const _sameLenInPlaceReplace =
         _tailFpCheckEnabled &&
-        messages.length === _lastMessagesCount &&
-        _lastMessagesCount > 0 &&
-        _lastTailFp !== '' &&
+        messages.length === _prevMessagesCount &&
+        _prevMessagesCount > 0 &&
+        _prevTailFp !== '' &&
         _deltaOriginalTailFp !== '' &&
-        _deltaOriginalTailFp !== _lastTailFp;
+        _deltaOriginalTailFp !== _prevTailFp;
 
       // 判断是否需要写 checkpoint
       const needsCheckpoint =
-        _lastMessagesCount === 0 ||                           // 进程重启 / 首次请求
-        messages.length < _lastMessagesCount ||               // messages 缩短（/clear、context 压缩）
+        _prevMessagesCount === 0 ||                           // 进程重启 / 首次请求
+        messages.length < _prevMessagesCount ||               // messages 缩短（/clear、context 压缩）
         (_mainAgentDeltaCount % CHECKPOINT_INTERVAL === 0) || // 定期 checkpoint
         _sameLenInPlaceReplace;                                // in-place last-msg replace 检测
 
@@ -643,12 +670,16 @@ export function setupInterceptor() {
         requestEntry._isCheckpoint = true;
         if (_sameLenInPlaceReplace) {
           // 诊断字段：标记此 checkpoint 是被 in-place replace 检测触发的（频率约 1-2%，
-          // 用于在生产 jsonl 里事后核对触发率，不影响重建逻辑）
+          // 用于在生产 jsonl 里事后核对触发率，不影响重建逻辑）。
+          // 双方协议（KEEP IN SYNC: src/utils/sessionManager.js applyInPlaceLastMsgReplace）：
+          // 客户端 helper 看到此字段=true（与 _isCheckpoint:true 同时存在）时直接 in-place 替换
+          // lastSession.messages 末位，跳过 sessionMerge prefix-overlap 算法（避开 doubled-history）。
+          // 字段重命名 / 删除前需同步两端 + 重跑双向回归测试。
           requestEntry._inPlaceReplaceDetected = true;
         }
       } else {
-        // delta：只保留新增的 messages
-        const delta = messages.slice(_lastMessagesCount);
+        // delta：只保留新增的 messages（必须用 _prevMessagesCount，不是 eager 已更新的 _lastMessagesCount）
+        const delta = messages.slice(_prevMessagesCount);
         requestEntry._deltaFormat = 1;
         requestEntry._totalMessageCount = messages.length;
         requestEntry._conversationId = 'mainAgent';

package/lib/git-diff.js

@@ -8,6 +8,15 @@ const execFileAsync = promisify(execFile);
 const UNTRACKED_MAX_BYTES = 5 * 1024 * 1024;
 const BINARY_PROBE_BYTES = 8192;
 
+// Reject only `..` as a path *segment* (start, between slashes, or end).
+// Substring match (`'node..modules'.includes('..')`) was rejecting valid paths.
+const PATH_TRAVERSAL = /(?:^|\/)\.\.(?:\/|$)/;
+
+// Whitelist for git ref names returned by `git rev-parse --abbrev-ref @{u}`.
+// Defense in depth: git-rev-parse output should never contain shell metacharacters,
+// but we validate before passing to `git log <upstream>..HEAD`.
+const SAFE_REF = /^[A-Za-z0-9_./\-]+$/;
+
 /**
  * Count inserted lines for an untracked file, matching `git diff --numstat`
  * semantics (line = `\n`-terminated run; an unterminated trailing run still
@@ -27,7 +36,7 @@ const BINARY_PROBE_BYTES = 8192;
  * @returns {number} inserted line count; 0 on any error, binary, or size cap
  */
 export function countUntrackedLines(cwd, file) {
-  if (!file || file.includes('..') || file.startsWith('/')) return 0;
+  if (!file || PATH_TRAVERSAL.test(file) || file.startsWith('/')) return 0;
   try {
     const fp = join(cwd, file);
     // Reject when the final component is a symlink (lstat doesn't follow).
@@ -51,32 +60,193 @@ export function countUntrackedLines(cwd, file) {
   }
 }
 
+/**
+ * Get commits between upstream and HEAD (i.e. local commits not yet pushed).
+ * Returns an empty list when:
+ *   - HEAD is detached (rev-parse --abbrev-ref HEAD prints "HEAD")
+ *   - Branch has no upstream (@{u} resolution fails)
+ *   - Working tree is at upstream (no commits ahead)
+ *
+ * Each commit includes its changed files via a single `git log --name-status` call,
+ * to avoid one git invocation per commit.
+ *
+ * @param {string} cwd
+ * @param {object} [opts]
+ * @param {number} [opts.maxCommits=100] hard cap to keep payload bounded
+ * @returns {Promise<{ commits: Array, hasUpstream: boolean, branch: string|null, upstream: string|null, truncated?: boolean, totalCount?: number }>}
+ */
+export async function getUnpushedCommits(cwd, { maxCommits = 100 } = {}) {
+  let branch = null;
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd, encoding: 'utf-8', timeout: 3000 });
+    branch = stdout.trim();
+  } catch {
+    return { commits: [], hasUpstream: false, branch: null, upstream: null };
+  }
+  if (!branch || branch === 'HEAD') {
+    return { commits: [], hasUpstream: false, branch, upstream: null };
+  }
+
+  let upstream = null;
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], { cwd, encoding: 'utf-8', timeout: 3000 });
+    upstream = stdout.trim();
+  } catch {
+    return { commits: [], hasUpstream: false, branch, upstream: null };
+  }
+  if (!upstream || !SAFE_REF.test(upstream)) {
+    return { commits: [], hasUpstream: false, branch, upstream: null };
+  }
+
+  // Use NUL separators between fields and a sentinel between commits to avoid
+  // getting fooled by tabs/newlines inside commit subjects.
+  // Format: <hash>\x1f<author>\x1f<date>\x1f<subject>\n
+  // Followed by one `<status>\t<path>` line per file (from --name-status).
+  // Commits separated by `\x1e` (record separator).
+  const COMMIT_SEP = '\x1e';
+  const FIELD_SEP = '\x1f';
+  let stdout = '';
+  try {
+    const r = await execFileAsync(
+      'git',
+      [
+        'log',
+        `--max-count=${maxCommits}`,
+        `--pretty=format:${COMMIT_SEP}%H${FIELD_SEP}%an${FIELD_SEP}%aI${FIELD_SEP}%s`,
+        '--name-status',
+        `${upstream}..HEAD`,
+      ],
+      { cwd, encoding: 'utf-8', timeout: 8000, maxBuffer: 10 * 1024 * 1024 }
+    );
+    stdout = r.stdout;
+  } catch {
+    return { commits: [], hasUpstream: true, branch, upstream };
+  }
+
+  const commits = [];
+  const blocks = stdout.split(COMMIT_SEP).filter(Boolean);
+  for (const block of blocks) {
+    const lines = block.split('\n');
+    const header = lines[0] || '';
+    const parts = header.split(FIELD_SEP);
+    if (parts.length < 4) continue;
+    const [hash, author, date, subject] = parts;
+    const files = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.trim()) continue;
+      const tab = line.indexOf('\t');
+      if (tab < 0) continue;
+      const st = line.substring(0, tab).trim();
+      const fp = line.substring(tab + 1);
+      if (!fp) continue;
+      files.push({ status: st[0] || 'M', file: fp });
+    }
+    commits.push({
+      hash,
+      shortHash: hash.substring(0, 7),
+      author,
+      date,
+      subject,
+      files,
+    });
+  }
+
+  // Detect truncation. 默认 truncated = (commits.length === maxCommits)，因为命中 cap 大概率
+  // 是被截了；rev-list --count 成功才用真实数据覆盖。这样如果 rev-list 失败/超时（大 repo
+  // 可能 >3s），用户至少能看到截断标记，不会被静默隐藏 200 条未推送 commit。
+  let totalCount = commits.length;
+  let truncated = commits.length === maxCommits;
+  if (truncated) {
+    try {
+      const r = await execFileAsync('git', ['rev-list', '--count', `${upstream}..HEAD`], { cwd, encoding: 'utf-8', timeout: 3000 });
+      const parsed = parseInt(r.stdout.trim(), 10);
+      if (Number.isFinite(parsed) && parsed > 0) {
+        totalCount = parsed;
+        truncated = totalCount > commits.length;
+      }
+    } catch {}
+  }
+
+  return { commits, hasUpstream: true, branch, upstream, truncated, totalCount };
+}
+
+/**
+ * Validate git commit hash. Accept 7..40 hex chars only.
+ * Rejects refs like "HEAD~1", branch names, anything with shell metacharacters.
+ * @param {string} hash
+ * @returns {boolean}
+ */
+export function isValidCommitHash(hash) {
+  return typeof hash === 'string' && /^[0-9a-f]{7,40}$/i.test(hash);
+}
+
 /**
  * Get git diffs for a list of files.
+ * When commitHash is provided, diffs come from `git show <hash>` (parent vs hash);
+ * otherwise from working tree vs HEAD (default behavior).
+ *
  * @param {string} cwd - working directory (git repo root)
  * @param {string[]} files - relative file paths
+ * @param {string} [commitHash] - optional commit SHA to diff against its first parent
  * @returns {Promise<Array>} diffs array
  */
-export async function getGitDiffs(cwd, files) {
+export async function getGitDiffs(cwd, files, commitHash) {
+  const useCommit = commitHash && isValidCommitHash(commitHash);
   const diffs = [];
 
+  // For commit-context diffs, get the per-file status table once instead of per file.
+  let commitStatusMap = null;
+  if (useCommit) {
+    try {
+      const { stdout } = await execFileAsync(
+        'git',
+        ['diff-tree', '-r', '--no-commit-id', '--name-status', '--root', commitHash],
+        { cwd, encoding: 'utf-8', timeout: 5000, maxBuffer: 5 * 1024 * 1024 }
+      );
+      commitStatusMap = new Map();
+      for (const line of stdout.split('\n')) {
+        if (!line.trim()) continue;
+        const tab = line.indexOf('\t');
+        if (tab < 0) continue;
+        const st = line.substring(0, tab).trim();
+        const fp = line.substring(tab + 1);
+        commitStatusMap.set(fp, st[0] || 'M');
+      }
+    } catch {
+      commitStatusMap = new Map();
+    }
+  }
+
   for (const file of files) {
     // 安全检查：防止路径穿越
-    if (file.includes('..') || file.startsWith('/')) continue;
+    if (PATH_TRAVERSAL.test(file) || file.startsWith('/')) continue;
 
     try {
-      const { stdout: statusOutput } = await execFileAsync('git', ['status', '--porcelain', '--', file], { cwd, encoding: 'utf-8', timeout: 3000 });
-      if (!statusOutput.trim()) continue;
+      let status;
+      let is_new;
+      let is_deleted;
 
-      const status = statusOutput.substring(0, 2).trim();
-      const is_new = status === 'A' || status === '??';
-      const is_deleted = status === 'D';
+      if (useCommit) {
+        status = commitStatusMap.get(file) || 'M';
+        is_new = status === 'A';
+        is_deleted = status === 'D';
+      } else {
+        const { stdout: statusOutput } = await execFileAsync('git', ['status', '--porcelain', '--', file], { cwd, encoding: 'utf-8', timeout: 3000 });
+        if (!statusOutput.trim()) continue;
+        status = statusOutput.substring(0, 2).trim();
+        is_new = status === 'A' || status === '??';
+        is_deleted = status === 'D';
+      }
 
       // 检查是否为二进制文件（已删除文件跳过）
       let is_binary = false;
       if (!is_deleted) {
         try {
-          const { stdout: diffCheck } = await execFileAsync('git', ['diff', '--numstat', 'HEAD', '--', file], { cwd, encoding: 'utf-8', timeout: 3000 });
+          const numstatArgs = useCommit
+            ? ['diff-tree', '-r', '--no-commit-id', '--numstat', '--root', commitHash, '--', file]
+            : ['diff', '--numstat', 'HEAD', '--', file];
+          const { stdout: diffCheck } = await execFileAsync('git', numstatArgs, { cwd, encoding: 'utf-8', timeout: 3000 });
           if (diffCheck.includes('-\t-\t')) {
             is_binary = true;
           }
@@ -87,31 +257,45 @@ export async function getGitDiffs(cwd, files) {
       let new_content = '';
 
       if (!is_binary) {
-        // 获取旧内容（HEAD 版本）
+        // 获取旧内容
         if (!is_new) {
           try {
-            const { stdout } = await execFileAsync('git', ['show', `HEAD:${file}`], { cwd, encoding: 'utf-8', timeout: 5000, maxBuffer: 5 * 1024 * 1024 });
+            const oldRef = useCommit ? `${commitHash}^:${file}` : `HEAD:${file}`;
+            const { stdout } = await execFileAsync('git', ['show', oldRef], { cwd, encoding: 'utf-8', timeout: 5000, maxBuffer: 5 * 1024 * 1024 });
             old_content = stdout;
           } catch {
             old_content = '';
           }
         }
 
-        // 获取新内容（工作区版本）
+        // 获取新内容
         if (!is_deleted) {
-          try {
-            const filePath = join(cwd, file);
-            if (existsSync(filePath)) {
-              const stat = statSync(filePath);
-              if (stat.size > 5 * 1024 * 1024) {
-                // 文件过大
-                diffs.push({ file, status, is_large: true, size: stat.size });
+          if (useCommit) {
+            try {
+              const { stdout } = await execFileAsync('git', ['show', `${commitHash}:${file}`], { cwd, encoding: 'utf-8', timeout: 5000, maxBuffer: 5 * 1024 * 1024 });
+              new_content = stdout;
+              if (Buffer.byteLength(new_content, 'utf-8') > 5 * 1024 * 1024) {
+                diffs.push({ file, status, is_large: true, size: Buffer.byteLength(new_content, 'utf-8') });
                 continue;
               }
-              new_content = readFileSync(filePath, 'utf-8');
+            } catch {
+              new_content = '';
+            }
+          } else {
+            try {
+              const filePath = join(cwd, file);
+              if (existsSync(filePath)) {
+                const stat = statSync(filePath);
+                if (stat.size > 5 * 1024 * 1024) {
+                  // 文件过大
+                  diffs.push({ file, status, is_large: true, size: stat.size });
+                  continue;
+                }
+                new_content = readFileSync(filePath, 'utf-8');
+              }
+            } catch {
+              new_content = '';
             }
-          } catch {
-            new_content = '';
           }
         }
       }

package/package.json

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

package/server.js

@@ -42,7 +42,7 @@ import { checkAndUpdate } from './lib/updater.js';
 import { loadPlugins, runWaterfallHook, runParallelHook, getPluginsInfo, getPluginsDir } from './lib/plugin-loader.js';
 import { uploadPlugins, installPluginFromUrl } from './lib/plugin-manager.js';
 import { getUserProfile } from './lib/user-profile.js';
-import { getGitDiffs, countUntrackedLines } from './lib/git-diff.js';
+import { getGitDiffs, countUntrackedLines, getUnpushedCommits, isValidCommitHash } from './lib/git-diff.js';
 import { CONTEXT_WINDOW_FILE, readModelContextSize, buildContextWindowEvent, getContextSizeForModel } from './lib/context-watcher.js';
 import { watchLogFile, startWatching, getWatchedFiles, sendEventToClients, sendToClients } from './lib/log-watcher.js';
 import { isMainAgentEntry, extractCachedContent } from './lib/kv-cache-analyzer.js';
@@ -3147,7 +3147,10 @@ async function handleRequest(req, res) {
       }
 
       const files = filesParam.split(',').map(f => f.trim()).filter(Boolean);
-      const diffs = await getGitDiffs(cwd, files);
+      const commitParam = parsedUrl.searchParams.get('commit');
+      // Reject malformed commit hashes; falsy = working-tree mode
+      const commitHash = commitParam && isValidCommitHash(commitParam) ? commitParam : undefined;
+      const diffs = await getGitDiffs(cwd, files, commitHash);
 
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify({ diffs }));
@@ -3158,6 +3161,27 @@ async function handleRequest(req, res) {
     return;
   }
 
+  // Local commits ahead of upstream (origin/<branch>..HEAD).
+  // Silent empty result when no upstream / detached HEAD — by design.
+  if (url.startsWith('/api/git-log-unpushed') && method === 'GET') {
+    try {
+      const repoParam = parsedUrl.searchParams.get('repo');
+      const cwd = resolveRepoCwd(repoParam);
+      if (!cwd) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Invalid repo parameter', commits: [], hasUpstream: false }));
+        return;
+      }
+      const result = await getUnpushedCommits(cwd);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    } catch (err) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: err.message, commits: [], hasUpstream: false }));
+    }
+    return;
+  }
+
   // 插件管理 API
   if (url === '/api/plugins' && method === 'GET') {
     const plugins = getPluginsInfo();