cc-viewer 1.7.4 → 1.7.6

package/server/proxy.js

@@ -1,7 +1,7 @@
 
 import { createServer } from 'node:http';
 import { readFileSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import * as interceptor from './interceptor.js';
 import { setupInterceptor } from './interceptor.js';
@@ -9,11 +9,19 @@ import { extractApiErrorMessage, formatProxyRequestError } from './lib/proxy-err
 import { getProxyDispatcher } from './lib/proxy-env.js';
 import { getClaudeConfigDir } from '../findcc.js';
 import { isAnthropicApiPath } from './lib/interceptor-core.js';
-import { executeRequest } from './lib/proxy-retry.js';
+import { executeRequest, extractModel } from './lib/proxy-retry.js';
+import { buildRecord, appendRecord, dailyFilePath, todayStr, emitProxyStatsUpdate } from './lib/proxy-stats.js';
+import { LOG_DIR } from '../findcc.js';
 
 // Setup interceptor to patch fetch
 setupInterceptor();
 
+// 通知 stats-worker 重扫 proxy 明细（review P2：原实现动态 import('./server.js') 反向触达
+// statsWorker 单例——若未来出现 proxy-only 进程，首条请求会因模块加载副作用意外拉起第二个
+// viewer。现在方向摆正：server.js（statsWorker 属主）加载时经 proxy-stats.js 的
+// setProxyStatsListener 注册回调，本模块只 emit；server 未加载则 emit 为 no-op）。
+const _notifyProxyStats = emitProxyStatsUpdate;
+
 // 强制上游返回未压缩响应，取代仅剥 zstd 的旧策略。
 // 原因：链路中的网关/代理（典型是本地 MITM 网络代理）可能把上游的压缩 body 原样透传，
 // 却把 content-encoding 响应头剥掉。undici 看不到 content-encoding 就不会解压，于是把一坨
@@ -123,7 +131,7 @@ export function startProxy() {
         const cleanReq = req.url.startsWith('/') ? req.url.slice(1) : req.url;
         const fullUrl = `${cleanBase}/${cleanReq}`;
 
-        // 大模型 API 请求（/v1/messages 等）走重试引擎：serial/race/stagger 重试。
+        // 大模型 API 请求（/v1/messages 等）走重试引擎：serial/race/stagger 重试 + 明细统计。
         // 重试引擎内部用 x-cc-viewer-trace 头让 interceptor 记录每次重试尝试到会话日志（网络视图数据源），
         // 模型替换由重试引擎用 resolveProfileModel 纯函数完成（interceptor 对 trace 请求会再跑一次，幂等 no-op）。
         // 非大模型 API 请求走原逻辑（同样用 x-cc-viewer-trace 让 interceptor 记录，但不经重试引擎）。
@@ -212,17 +220,18 @@ export function startProxy() {
   });
 }
 
-// ── 大模型 API 请求处理：重试引擎 ──────────────────────
-// mode=off 时退化为单次 fetch（与原透传一致）。
+// ── 大模型 API 请求处理：重试引擎 + 明细统计 ──────────────────────
+// mode=off 时仍写 1 条明细（attempts=1）以支撑可用率统计；完全禁用统计用 CCV_PROXY_STATS=off。
 // 重试配置由 interceptor._retryConfigState 提供（live binding，watchFile 热刷新），
 // 每请求取最新值，UI 改 retry-config.json 后下一个请求即生效，无需重启。
 const _retryConfigGetter = () => interceptor._retryConfigState;
 
 async function handleLlmApiRequest(req, res, fullUrl, fetchOptions, body, proxyDispatcher) {
+  const statsEnabled = process.env.CCV_PROXY_STATS !== 'off';
   const retryConfig = _retryConfigGetter(); // live binding：每请求取最新重试配置
   const profile = interceptor._activeProfile || null;
 
-  // 清理可能的 trace 头（executeRequest 会重新加，避免旧值干扰）；interceptor 会正常记录请求
+  // 清理可能的 trace 头（singleFetch 会重新加，避免旧值干扰）；interceptor 会正常记录请求
   // 同时清理 hop-by-hop / 传输编码头：body 已被 buffer 成完整 Buffer，
   // 残留的 transfer-encoding:chunked / content-length 会让 undici 拒绝（invalid transfer-encoding header）
   const retryFetchOptions = {
@@ -240,6 +249,9 @@ async function handleLlmApiRequest(req, res, fullUrl, fetchOptions, body, proxyD
     retryFetchOptions.body = body;
   }
 
+  // Model name for the stats detail record (extracted from the request body)
+  const model = extractModel(body);
+
   // Client-disconnect propagation: without this, a client that gave up leaves
   // the retry loop hammering (and billing) the upstream for up to
   // maxRetryDurationMs. res 'close' before the response is finished means the
@@ -259,7 +271,7 @@ async function handleLlmApiRequest(req, res, fullUrl, fetchOptions, body, proxyD
     ctx: { dispatcher: proxyDispatcher, profile, signal: clientAbort.signal },
   });
 
-  const { response, attempts, finalStatus } = result;
+  const { response, attempts, retryCodes, durationMs, finalStatus, succeeded, upstreamStatus } = result;
 
   // Client already gone: nothing to write; the engine has aborted upstream work.
   if (clientAbort.signal.aborted || res.writableEnded) {
@@ -277,6 +289,37 @@ async function handleLlmApiRequest(req, res, fullUrl, fetchOptions, body, proxyD
   }
   responseHeaders['x-forward-attempts'] = String(attempts);
 
+  // 写代理重试明细（主线程写，之后通知 stats-worker 重扫聚合）
+  if (statsEnabled && interceptor._projectName) {
+    try {
+      const projectDir = join(LOG_DIR, interceptor._projectName);
+      const filePath = dailyFilePath(projectDir, todayStr());
+      const record = buildRecord({
+        method: req.method,
+        path: req.url,
+        model,
+        profileId: profile?.id || 'default',
+        profileName: profile?.name || 'Default',
+        // Review P2 fix: upstreamStatus was hard-wired to finalStatus, killing
+        // the dual-status distinction (race/stagger fallbacks can differ).
+        upstreamStatus: upstreamStatus ?? finalStatus,
+        finalStatus,
+        attempts,
+        durationMs,
+        succeeded,
+        retryCodes,
+      });
+      appendRecord(filePath, record);
+      // 通知 stats-worker 重扫该 proxy 明细文件（缓存 dynamic import，非每请求新建）
+      const fileName = basename(filePath);
+      _notifyProxyStats(fileName);
+    } catch (err) {
+      if (process.env.CCV_DEBUG) {
+        console.error('[CC-Viewer Proxy] Failed to write proxy stats:', err.message);
+      }
+    }
+  }
+
   // 网络异常（finalStatus=0）或竞速全失败：返回 502 + Proxy Error，与原 catch 分支一致
   if (finalStatus === 0) {
     res.writeHead(502, { 'x-forward-attempts': String(attempts) });

package/server/pty-manager.js

@@ -231,6 +231,14 @@ async function _spawnClaudeImpl(proxyPort, cwd, extraArgs = [], claudePath = nul
   }
 
   const env = { ...process.env };
+  // CodeFuse owns and versions the Claude binary used by `cfuse --ccv`. Keep
+  // that managed 2.1.x binary from invoking Claude Code's independent updater;
+  // upgrades must come from CodeFuse so the enterprise-approved version cannot
+  // be silently replaced during a CCV session.
+  const normalizedClaudePath = String(claudePath || '').replace(/\\/g, '/');
+  if (normalizedClaudePath.includes('/.codefuse/fuse/engine/bin/claude/')) {
+    env.DISABLE_AUTOUPDATER = '1';
+  }
   env.ANTHROPIC_BASE_URL = `http://127.0.0.1:${proxyPort}`;
   env.CCV_PROXY_MODE = '1'; // 告诉 interceptor.js 不要再启动 server
   env.CCV_LOG_DIR = LOG_DIR; // 让 fork 出的 Claude Code 进程找到同一份 profile.json 等资源

package/server/routes/preferences.js

@@ -302,7 +302,7 @@ function proxyProfilesPost(req, res, parsedUrl, isLocal, deps) {
   });
 }
 
-// ── 代理重试配置（GET/POST，仿 proxyProfilesGet/Post，但无密钥脱敏、无 workspace 隔离）──
+// ── 代理重试配置（GET/POST + SSE，仿 proxyProfilesGet/Post，但无密钥脱敏、无 workspace 隔离）──
 // 返回 { config, defaults }：config = 当前生效（env 基础 + retry-config.json 覆盖后的 live binding）；
 // defaults = DEFAULT_RETRY_CONFIG，供 UI「恢复默认」按钮参照。
 

package/server/routes/proxy-stats.js

@@ -0,0 +1,95 @@
+// Proxy retry stats routes — HTTP endpoints for proxy retry statistics.
+//
+// The stats-worker scans proxy_*.jsonl detail logs and aggregates them into the
+// proxyStats field of <project>/<project>.json (same file as token stats). These
+// routes only read that data and trigger refreshes.
+//
+// Route shape follows the _dispatch.js descriptor convention:
+//   { method, match: 'exact'|'prefix', path, handler(req, res, parsedUrl, isLocal, deps) }
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { LOG_DIR } from '../../findcc.js';
+import { _projectName } from '../interceptor.js';
+
+// GET /api/proxy-stats — returns the current project's proxy retry stats (proxyStats field).
+// Response body: { proxyStats: {...} }; proxyStats is null when there is no data.
+function getProxyStats(req, res) {
+  try {
+    if (!_projectName) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'No project name', proxyStats: null }));
+      return;
+    }
+    const statsFile = join(LOG_DIR, _projectName, `${_projectName}.json`);
+    if (!existsSync(statsFile)) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ proxyStats: null }));
+      return;
+    }
+    const stats = JSON.parse(readFileSync(statsFile, 'utf-8'));
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ proxyStats: stats.proxyStats || null }));
+  } catch (err) {
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: err.message, proxyStats: null }));
+  }
+}
+
+// POST /api/refresh-proxy-stats — triggers a full re-scan by the stats-worker (including proxy detail aggregation).
+// Reuses the existing worker's scan-all message mechanism; shares the same worker as /api/refresh-stats.
+// scan-all refreshes both token stats and proxy stats (both are produced in the same generateProjectStats run).
+//
+// Review P2 fix — in-flight coalescing: the old handler attached one worker
+// listener per request (30s lifetime → listener pile-up under repeated
+// clicks/floods) and resolved on ANY scan-all-done (two concurrent refreshes
+// cross-resolved each other). Now a module-level latch: the first request
+// starts ONE scan with ONE listener; requests arriving while it runs just
+// join the waiter list and share its completion. A flood of POSTs therefore
+// costs a single full scan instead of N.
+let _refreshWaiters = null; // Array<res> while a scan is in flight
+
+function refreshProxyStats(req, res, parsedUrl, isLocal, deps) {
+  try {
+    if (!deps.statsWorker) deps.startStatsWorker();
+    if (!deps.statsWorker) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Stats worker not available' }));
+      return;
+    }
+    if (_refreshWaiters) {
+      _refreshWaiters.push(res); // join the in-flight scan
+      return;
+    }
+    _refreshWaiters = [res];
+    const worker = deps.statsWorker;
+    const finish = (status, body) => {
+      const waiters = _refreshWaiters || [];
+      _refreshWaiters = null;
+      clearTimeout(timeout);
+      worker.removeListener('message', onDone);
+      const payload = JSON.stringify(body);
+      for (const r of waiters) {
+        try {
+          r.writeHead(status, { 'Content-Type': 'application/json' });
+          r.end(payload);
+        } catch { /* client may have disconnected while waiting */ }
+      }
+    };
+    const timeout = setTimeout(() => finish(504, { error: 'Proxy stats refresh timed out' }), 30000);
+    timeout.unref?.();
+    const onDone = (m) => {
+      if (m.type === 'scan-all-done') finish(200, { ok: true });
+    };
+    worker.on('message', onDone);
+    worker.postMessage({ type: 'scan-all', logDir: LOG_DIR });
+  } catch (err) {
+    _refreshWaiters = null;
+    res.writeHead(500, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ error: err.message }));
+  }
+}
+
+export const proxyStatsRoutes = [
+  { method: 'GET', match: 'exact', path: '/api/proxy-stats', handler: getProxyStats },
+  { method: 'POST', match: 'exact', path: '/api/refresh-proxy-stats', handler: refreshProxyStats },
+];

package/server/server.js

@@ -40,6 +40,8 @@ import { teamRoutes } from './routes/team.js';
 import { authRoutes } from './routes/auth.js';
 import { dingtalkRoutes } from './routes/dingtalk.js';
 import { imRoutes } from './routes/im.js';
+import { proxyStatsRoutes } from './routes/proxy-stats.js';
+import { setProxyStatsListener } from './lib/proxy-stats.js';
 import * as imCore from './lib/im-bridge-core.js';
 import * as imProcMgr from './lib/im-process-manager.js';
 import './lib/adapters/dingtalk-adapter.js'; // side-effect: registers the DingTalk adapter
@@ -431,6 +433,34 @@ function notifyStatsWorker(logFile) {
   }
 }
 
+// 供 proxy.js 在写入代理重试明细后通知 stats-worker 重扫聚合。
+// 单独 export 避免循环依赖（proxy.js 不能直接 import server.js 的 deps）。
+// Review P1 fix: one worker message per proxied LLM request made the worker
+// re-aggregate the whole project on EVERY request (O(N²) over a busy day —
+// the session-log path has the log-watcher debounce, the proxy path had
+// none). Trailing coalesce: the first notify schedules a flush, further
+// notifies within the window only update the pending file. unref() so a
+// pending flush never holds the process open on shutdown.
+const PROXY_STATS_DEBOUNCE_MS = 2000;
+let _proxyStatsFlushTimer = null;
+let _proxyStatsPendingFile = null;
+export function notifyProxyStats(logFile) {
+  _proxyStatsPendingFile = logFile;
+  if (_proxyStatsFlushTimer) return;
+  _proxyStatsFlushTimer = setTimeout(() => {
+    _proxyStatsFlushTimer = null;
+    const pending = _proxyStatsPendingFile;
+    _proxyStatsPendingFile = null;
+    if (!statsWorker) startStatsWorker();
+    notifyStatsWorker(pending);
+  }, PROXY_STATS_DEBOUNCE_MS);
+  _proxyStatsFlushTimer.unref?.();
+}
+// Dependency inversion (review P2): server.js owns the statsWorker, so IT
+// registers the notify callback with the proxy-stats lib; proxy.js only emits
+// through the lib and never reaches back into this module.
+setProxyStatsListener(notifyProxyStats);
+
 const MIME_TYPES = {
   '.html': 'text/html; charset=utf-8',
   '.js': 'application/javascript; charset=utf-8',
@@ -662,6 +692,7 @@ const _routes = [
   ...teamRoutes,
   ...dingtalkRoutes,
   ...imRoutes,
+  ...proxyStatsRoutes,
 ];
 const dispatch = createDispatcher(_routes);
 

package/src/utils/isProxyMode.js

@@ -0,0 +1,11 @@
+// Shared proxy-mode detection logic.
+// Used by App.jsx (showProxyStatsNav gate) and AppHeader.jsx (menu visibility, Electron tab bar).
+//
+// "Confirmed proxy" = a non-built-in profile is active, or the built-in Default
+// points at a non-official endpoint (same api.anthropic.com test as ProxyModal's
+// Max warning). Official subscription → returns false.
+export function isProxyMode(activeProxyId, defaultConfig) {
+  if (activeProxyId && activeProxyId !== 'max') return true;
+  const origin = defaultConfig?.origin || '';
+  return !!origin && !/api\.anthropic\.com/i.test(origin);
+}