ccus-cli 0.2.5 → 0.2.7

package/README.md

@@ -252,6 +252,7 @@ ccus api config    # 不带参数：打印当前配置
 - **缓存**：statusline 高频调用，额度按 TTL 缓存（默认 5 分钟，`--ttl 5m` 改），拉取失败自动回退上次缓存；缓存文件 `api-quota-cache.json`。
 - **智谱请求头**：除 `Authorization` 外，`--project` / `--organization` 会作为 `bigmodel-project` / `bigmodel-organization` 头发出（团队版需要）。接口对请求来源敏感，若返回空响应疑似被拦，可用 `ccus api config --user-agent "<浏览器UA>"` 改 UA。
 - **自定义 provider**：`--provider custom` 配其它厂商。简单响应用 `--url` / `--method` / `--header "K: V; K2: V2"`（header 值支持 `{{token}}` 占位）/ `--five-hour-path` / `--seven-day-path`（点分路径，如 `data.limits.0.percentage`）映射字段；响应结构复杂（数组筛选/排序）时用 `--extractor-file script.js` 写一段 JS 函数，接收响应对象、返回 `{ fiveHour, sevenDay }` 或 cc-switch 风格的 `[{used}, {used}]`，配了 extractor 就优先于点分路径。脚本在 ccus 进程内执行，只放信任的来源。
+- **统一 env 代理**：智谱 / custom 的额度请求经 ccus 统一代理通道（读 `https_proxy` / `http_proxy` / `all_proxy` / `NO_PROXY`，小写优先、对齐 curl），代理环境也能拉到额度；想给 ccus 单独指定代理（覆盖系统代理）用专属的 `CCUS_PROXY`（同时管 https / http 目标，仍受 `NO_PROXY` 约束），无代理变量维持直连。
 
 > API 模式填充的 5h/7d 会和官方 `rate_limits` 走同一条聚合管线（含 7d 累计去毛刺算法，该算法针对 Claude 官方锯齿波设计）；不同厂商的额度曲线语义可能不完全一致，混用聚合时注意。
 
@@ -293,7 +294,8 @@ ccus install --codex --uninstall          # 移除 ccus 的 Stop hook
 要点：
 
 - **只支持 Codex CLI**：hooks 与 `codex app-server` 都是 CLI 能力。Codex 桌面版 app（已并入 ChatGPT 桌面 app）不一定触发 CLI 的 hooks、也不一定随附可 spawn 的 `codex` 二进制，不在本期范围。
-- **代理继承**：ccus 由 Codex 直接 spawn，已继承 Codex 的代理 / `CODEX_HOME`；它再 spawn `codex app-server` 时透传 `process.env`，整条链同环境。必须让 codex 子进程发请求（它读 `HTTP_PROXY`/`HTTPS_PROXY`），不能用 ccus 自己的 Node `fetch`（裸 fetch 不读代理、代理环境下直连失败）。
+- **代理继承**：ccus 由 Codex 直接 spawn，已继承 Codex 的代理 / `CODEX_HOME`；它再 spawn `codex app-server` 时透传 `process.env`，整条链同环境。主路径必须让 codex 子进程发请求（它读 `HTTP_PROXY` / `HTTPS_PROXY`）；wham 回退走 ccus 自己的 Node HTTP，但经统一 env 代理通道（读 `CCUS_PROXY` / `https_proxy` / `http_proxy` / `all_proxy` / `NO_PROXY`，`CCUS_PROXY` 优先、小写优先、对齐 curl），代理环境同样可达。
+- **无 codex 命令时回退 wham**：本机没装 `codex` CLI（spawn 返回 `unavailable`）且无新鲜缓存时，ccus 改走 ChatGPT 后端 `wham/usage` HTTP 直连——读 `~/.codex/auth.json` 的 OAuth token（仅 chatgpt 登录模式）、按各窗 `limit_window_seconds` 认 5h / 7d 桶，照常落盘 `source="codex"` 事件。让「装过 codex 留下 hook + auth.json、但 codex 未入 PATH / 已卸载」的用户也能采到额度。仅 `unavailable` 触发，超时 / RPC 错（`error`）不回退。
 - **定时同步**：Stop hook 还兜底触发 `ccus sync`（与 Claude statusline 对称）——配过 `ccus sync config --target` 后，Codex 每 turn 结束都会检查 3h 周期，到期自动 export + 复制 bundle（含 Codex token/消息）到目标目录。只用 Codex、不开 Claude Code 时也能自动同步。
 - **缓存节流**：Stop 每 turn 触发，额度按 5 分钟 TTL 缓存（`codex-quota-cache.json`），命中秒回不 spawn；过期才拉一次（带 ~10s 超时），失败回退旧缓存。
 - **字段映射**：app-server 返回 `primary`（5h）/ `secondary`（weekly）两窗口，取各自的 `usedPercent`（驼峰，clamp 0–100）；ccus 填进 `rate_limits.five_hour` / `seven_day` 的 `used_percentage`，`computeStatuslineEvent` 读时自动算出 usage。

package/dist/lib/aggregate.js

@@ -411,8 +411,11 @@ function buildSevenDayCurveFromEvents(events) {
 }
 /**
  * 同一 personKey 的 7d 累计曲线：把该人**所有 bundle**（非仅 winner）的 rawEvents 计算成事件、
- * 取非 null `sevenDayUsagePct`、按 timestamp 升序合并、对完全相同 timestamp 去重，再做读数去毛刺，
- * 得到一条账号级曲线。
+ * 取非 null `sevenDayUsagePct`、按 timestamp 升序合并、对完全相同 timestamp 去重，再做读数去毛刺。
+ *
+ * Claude 与 Codex 是两个不同额度池的独立曲线（读数水平常常相差悬殊），按 source 各自建一条，
+ * 算累计时分别做分段峰谷和再相加。混成一条会让低位源频繁触发假 reset、把高位源的上升段反复重算，
+ * 导致累计严重虚高（实测 jizhiqiang 混算 221% vs 分源相加 44%）。
  *
  * 走全样本而非 winner，是因为累计指标是同一条共享额度曲线的密集采样：只取 winner 会漏掉非 winner
  * 机器的样本（曲线稀疏、累计偏小），分机各自累计再相加又会翻倍。结果按 bundles 数组缓存复用。
@@ -423,27 +426,31 @@ function buildPersonSevenDayCurve(bundles) {
     if (cached) {
         return cached;
     }
-    const collected = new Map();
+    const claudeByPerson = new Map();
+    const codexByPerson = new Map();
     for (const { bundle } of bundles) {
         const personKey = bundlePersonKey(bundle);
-        // 含 Claude + Codex 两源读数：codex 7d 读数不再过滤，并入同一条曲线算累计
         for (const record of bundle.rawEvents.filter((r) => isPersistedStatuslineEvent(r))) {
             const event = (0, payload_1.computeStatuslineEvent)(record);
             if (event.sevenDayUsagePct === null) {
                 continue;
             }
-            const list = collected.get(personKey);
+            const target = (0, payload_1.isCodexSourceEvent)(event) ? codexByPerson : claudeByPerson;
+            const list = target.get(personKey);
             if (list) {
                 list.push(event);
             }
             else {
-                collected.set(personKey, [event]);
+                target.set(personKey, [event]);
             }
         }
     }
     const curves = new Map();
-    for (const [personKey, events] of collected.entries()) {
-        curves.set(personKey, buildSevenDayCurveFromEvents(events));
+    for (const personKey of new Set([...claudeByPerson.keys(), ...codexByPerson.keys()])) {
+        curves.set(personKey, {
+            claude: buildSevenDayCurveFromEvents(claudeByPerson.get(personKey) ?? []),
+            codex: buildSevenDayCurveFromEvents(codexByPerson.get(personKey) ?? []),
+        });
     }
     personSevenDayCurveCache.set(bundles, curves);
     return curves;
@@ -456,6 +463,18 @@ function sliceCurveByDate(curve, date) {
 function sliceCurveByWeek(curve, week) {
     return curve.filter((event) => weekKey(new Date(event.timestamp)) === week);
 }
+/**
+ * 分源 7d 累计：Claude 与 Codex 各自按区间切片做分段峰谷和，再用 `addNullable` 相加。
+ * 两源是不同额度池的独立曲线，混算会互相触发假 reset 而虚高；分源算后相加，与 CSV 里 token /
+ * 消息数「Claude+Codex 合计」口径一致。该 personKey 无任何曲线、或两源都无有效样本时返回 null。
+ */
+function computeCumulativeSevenDayBySource(curves, personKey, slicer, rangeKey) {
+    const bySource = curves.get(personKey);
+    if (!bySource) {
+        return null;
+    }
+    return addNullable(computeCumulativeSevenDay(slicer(bySource.claude, rangeKey)), computeCumulativeSevenDay(slicer(bySource.codex, rangeKey)));
+}
 /** 从一组事件按真实时间戳重算 5h / 7d 的 peak（max）与 latest（时间戳最新非空）。 */
 function recomputeUsage(events) {
     const newestFirst = [...events].sort((left, right) => new Date(right.timestamp).getTime() - new Date(left.timestamp).getTime());
@@ -526,8 +545,8 @@ function buildAggregatedDailyRows(bundles) {
         const codexUsage = recomputeUsage(codexEvents);
         // 额度回退：rawEvents 缺时从 daySummary 取（Claude+Codex 合并，见 fallbackWeeklyUsage）
         const fallback = fallbackWeeklyUsage(reps.map((r) => r.day));
-        // 累计指标走全样本合并曲线，不走单机的 recomputeUsage，避免漏掉另一台机器的样本。
-        const sevenDayCumulativeUsagePct = computeCumulativeSevenDay(sliceCurveByDate(curves.get(personKey) ?? [], date));
+        // 累计指标走全样本分源曲线（Claude + Codex 各自切片累计后相加），不走单机的 recomputeUsage，避免漏掉另一台机器的样本。
+        const sevenDayCumulativeUsagePct = computeCumulativeSevenDayBySource(curves, personKey, sliceCurveByDate, date);
         rows.push({
             personKey,
             date,
@@ -621,8 +640,8 @@ function buildAggregatedWeeklyRows(bundles) {
         const usage = recomputeUsage(claudeEvents);
         const codexUsage = recomputeUsage(codexEvents);
         const fallback = fallbackWeeklyUsage(acc.days);
-        // 整周累计：在整周合并曲线上一次性求正增量，跨天边界增量被计入，故 weekly ≥ Σ daily。
-        const sevenDayCumulativeUsagePct = computeCumulativeSevenDay(sliceCurveByWeek(curves.get(acc.personKey) ?? [], acc.week));
+        // 整周累计：Claude + Codex 各自在整周子曲线上做分段峰谷和后相加，跨天边界增量被计入，故 weekly ≥ Σ daily。
+        const sevenDayCumulativeUsagePct = computeCumulativeSevenDayBySource(curves, acc.personKey, sliceCurveByWeek, acc.week);
         rows.push({
             personKey: acc.personKey,
             week: acc.week,

package/dist/lib/api-mode.js

@@ -13,6 +13,9 @@ exports.resolveApiTokenWithSettings = resolveApiTokenWithSettings;
 exports.extractCustomQuota = extractCustomQuota;
 exports.runExtractor = runExtractor;
 exports.normalizeExtractorResult = normalizeExtractorResult;
+exports.isNoProxyHost = isNoProxyHost;
+exports.resolveProxyUrl = resolveProxyUrl;
+exports.httpRequest = httpRequest;
 exports.fetchQuota = fetchQuota;
 exports.readApiQuotaCacheSync = readApiQuotaCacheSync;
 exports.resolveApiQuota = resolveApiQuota;
@@ -308,19 +311,130 @@ function extractArrayNumber(item) {
     }
     return null;
 }
-/** 按 url 协议发起 HTTP(S) 请求，返回 {status, body}；超时或错误 reject（仿 fetchLatestVersion）。 */
-function httpRequest(url, opts) {
-    return new Promise((resolve, reject) => {
-        let parsed;
+/** 按顺序取第一个非空（去空白后非空）的环境变量值。 */
+function pickEnv(env, ...names) {
+    for (const name of names) {
+        const v = env[name];
+        if (typeof v === "string" && v.trim() !== "") {
+            return v.trim();
+        }
+    }
+    return undefined;
+}
+/**
+ * NO_PROXY 匹配：逗号 / 空白分隔的域名后缀，支持精确匹配、后缀匹配、`*` 全匹配（对齐 curl / proxy-from-env）。
+ * 每项可带前导 `.`（`.example.com` 等价 `example.com`）；hostname 命中任一项即视为应直连。
+ */
+function isNoProxyHost(hostname, noProxy) {
+    const items = noProxy
+        .split(/[\s,]+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    for (const raw of items) {
+        if (raw === "*") {
+            return true;
+        }
+        const item = raw.startsWith(".") ? raw.slice(1) : raw;
+        if (item === hostname || hostname.endsWith(`.${item}`)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 按环境变量解析目标 URL 应走的代理（对齐 curl / proxy-from-env），纯函数、可单测。
+ *
+ * https 目标读 `https_proxy` → `HTTPS_PROXY` → `all_proxy` → `ALL_PROXY`；
+ * http 目标读 `http_proxy` → `HTTP_PROXY` → `all_proxy` → `ALL_PROXY`。**小写优先**。
+ * `NO_PROXY` / `no_proxy`（小写优先）命中的主机、或无任何代理变量时返回 null（直连）。
+ */
+function resolveProxyUrl(targetUrl, env) {
+    let parsed;
+    try {
+        parsed = new URL(targetUrl);
+    }
+    catch {
+        return null;
+    }
+    const noProxy = pickEnv(env, "no_proxy", "NO_PROXY");
+    if (noProxy && isNoProxyHost(parsed.hostname, noProxy)) {
+        return null;
+    }
+    // CCUS_PROXY：ccus 专属代理，单一值同时管 https / http 目标，优先于标准 https_proxy / http_proxy / all_proxy。
+    const ccusProxy = pickEnv(env, "CCUS_PROXY");
+    if (ccusProxy) {
+        return ccusProxy;
+    }
+    const isHttps = parsed.protocol === "https:" || parsed.protocol === "wss:";
+    const proxy = isHttps
+        ? pickEnv(env, "https_proxy", "HTTPS_PROXY", "all_proxy", "ALL_PROXY")
+        : pickEnv(env, "http_proxy", "HTTP_PROXY", "all_proxy", "ALL_PROXY");
+    return proxy ?? null;
+}
+/**
+ * 懒加载两个代理 agent 构造器，模块级缓存。
+ *
+ * 这两个包是 ESM-only：ccus 是 CommonJS，Node 20/21 的顶层 `require(esm)` 会 `ERR_REQUIRE_ESM`。
+ * 必须用**原生**动态 `import()`（CJS 里对全 Node 版本可异步加载 ESM）；但 tsc 在 `module: commonjs` 下会把
+ * `import()` 降级成 `require`（Node 20 仍崩），故用 `new Function` 构造一个运行时 `import()`，绕过 tsc 降级。
+ * 加载失败返回 null（回退直连）。
+ */
+const nativeImport = new Function("specifier", "return import(specifier)");
+let proxyAgentsPromise = null;
+function loadProxyAgents() {
+    if (proxyAgentsPromise) {
+        return proxyAgentsPromise;
+    }
+    proxyAgentsPromise = (async () => {
         try {
-            parsed = new URL(url);
+            const [httpsMod, httpMod] = (await Promise.all([
+                nativeImport("https-proxy-agent"),
+                nativeImport("http-proxy-agent"),
+            ]));
+            return {
+                HttpsProxyAgent: httpsMod.HttpsProxyAgent,
+                HttpProxyAgent: httpMod.HttpProxyAgent,
+            };
         }
-        catch {
-            reject(new Error(`invalid url: ${url}`));
-            return;
+        catch (error) {
+            (0, debug_1.debugLog)("api-mode", "failed to load proxy agent modules", error instanceof Error ? error.message : String(error));
+            return null;
         }
-        const transport = parsed.protocol === "http:" ? node_http_1.default : node_https_1.default;
-        const request = transport.request(url, { method: opts.method, headers: opts.headers }, (response) => {
+    })();
+    return proxyAgentsPromise;
+}
+/**
+ * 按 url 协议发起 HTTP(S) 请求，返回 {status, body}；超时或错误 reject。
+ *
+ * 自带 env 代理支持（wham 回退 / 智谱 / custom 共用一条通道）：有代理则给请求挂 `https-proxy-agent` /
+ * `http-proxy-agent`，无代理 / `NO_PROXY` 命中 / 代理模块加载失败时维持默认 globalAgent。`env` 默认
+ * `process.env`，对无代理环境行为零变化。
+ */
+async function httpRequest(url, opts, env = process.env) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`invalid url: ${url}`);
+    }
+    const transport = parsed.protocol === "http:" ? node_http_1.default : node_https_1.default;
+    const requestOptions = { method: opts.method, headers: opts.headers };
+    const proxyUrl = resolveProxyUrl(url, env);
+    if (proxyUrl) {
+        const agents = await loadProxyAgents();
+        if (agents) {
+            try {
+                requestOptions.agent =
+                    parsed.protocol === "http:" ? new agents.HttpProxyAgent(proxyUrl) : new agents.HttpsProxyAgent(proxyUrl);
+            }
+            catch (error) {
+                (0, debug_1.debugLog)("api-mode", "failed to create proxy agent, falling back to direct", error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+    return new Promise((resolve, reject) => {
+        const request = transport.request(url, requestOptions, (response) => {
             const status = response.statusCode ?? 0;
             let body = "";
             response.setEncoding("utf8");

package/dist/lib/codex-fetcher.js

@@ -3,7 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCodexAuth = readCodexAuth;
 exports.fetchCodexQuota = fetchCodexQuota;
+exports.parseWhamUsage = parseWhamUsage;
+exports.fetchCodexQuotaViaWham = fetchCodexQuotaViaWham;
 exports.readCodexQuotaCacheSync = readCodexQuotaCacheSync;
 exports.resolveCodexQuota = resolveCodexQuota;
 const node_child_process_1 = require("node:child_process");
@@ -12,12 +15,19 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const debug_1 = require("./debug");
+const api_mode_1 = require("./api-mode");
 const paths_1 = require("./paths");
 // app-server 子进程参数：read-only + untrusted，Codex 官方推荐的最低权限拉额度姿态。
 const CODEX_ARGS = ["-s", "read-only", "-a", "untrusted", "app-server"];
 const DEFAULT_TIMEOUT_MS = 10_000;
 // notify 每 turn 触发，额度缓存 5 分钟，命中秒回避免阻塞 Codex 主流程。
 const DEFAULT_TTL_MS = 5 * 60 * 1000;
+// ChatGPT 后端 wham/usage 回退：仅本机无 codex CLI（spawn unavailable）时走，直连读 auth.json 的 OAuth token。
+const WHAM_USAGE_URL = "https://chatgpt.com/backend-api/wham/usage";
+const WHAM_TIMEOUT_MS = 15_000;
+// wham 各窗口自带的时长（秒）：5h 窗 18000、周窗 604800，按它认桶、不假设 primary/secondary 顺序。
+const WHAM_SESSION_WINDOW_SECONDS = 18000;
+const WHAM_WEEKLY_WINDOW_SECONDS = 604800;
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -136,6 +146,36 @@ function parseRateLimitsResult(result) {
 function getCodexHome(codexHomePath) {
     return codexHomePath ?? process.env.CODEX_HOME ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".codex");
 }
+/**
+ * 读 `$CODEX_HOME/auth.json`（默认 `~/.codex/auth.json`）的 OAuth token，仅 `auth_mode === "chatgpt"` 返回。
+ *
+ * 对齐 cc-switch 文件源结构 `{ auth_mode, tokens: { access_token, account_id }, last_refresh }`。
+ * 缺文件 / API key 模式（auth_mode !== "chatgpt"）/ 结构异常均返回 null，绝不抛错。不实现 refresh、不读 Keychain。
+ * auth.json 结构随 Codex 升级变、易碎，解析宽松、缺字段放弃。
+ */
+function readCodexAuth(codexHomePath) {
+    try {
+        const authPath = (0, node_path_1.join)(getCodexHome(codexHomePath), "auth.json");
+        const raw = node_fs_1.default.readFileSync(authPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed) || parsed.auth_mode !== "chatgpt") {
+            return null;
+        }
+        const tokens = parsed.tokens;
+        if (!isRecord(tokens)) {
+            return null;
+        }
+        const accessToken = typeof tokens.access_token === "string" && tokens.access_token.trim() !== "" ? tokens.access_token : null;
+        if (!accessToken) {
+            return null;
+        }
+        const accountId = typeof tokens.account_id === "string" && tokens.account_id.trim() !== "" ? tokens.account_id : null;
+        return { accessToken, accountId };
+    }
+    catch {
+        return null;
+    }
+}
 function buildRpcMessage(id, method, params) {
     return `${JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} })}\n`;
 }
@@ -266,6 +306,125 @@ async function fetchCodexQuota(options = {}) {
         });
     });
 }
+// --- wham/usage HTTP 直连回退（仅主路径 unavailable 时由 resolveCodexQuota 编排） ---
+/** 读 wham 窗口使用率：主字段 `used_percent`（下划线，wham 实际返回），驼峰 / `used_percentage` 防御性 fallback；窗口为 null 返回 null。 */
+function readWhamUsedPercent(window) {
+    if (!window) {
+        return null;
+    }
+    return clampPercent(toFiniteNumber(window.used_percent ?? window.usedPercent ?? window.used_percentage));
+}
+/** 读 wham 窗口重置时间：`reset_at` Unix 秒；< 10^10 视为秒转毫秒，否则按毫秒；窗口为 null 返回 null。 */
+function readWhamResetsAtMs(window) {
+    if (!window) {
+        return null;
+    }
+    const n = toFiniteNumber(window.reset_at ?? window.resetsAt);
+    if (n === null) {
+        return null;
+    }
+    return n < 10_000_000_000 ? n * 1000 : n;
+}
+/** 按窗口时长（秒）认桶：18000→5h、604800→7d，未知返回 null。 */
+function classifyWhamWindow(seconds) {
+    if (seconds === null) {
+        return null;
+    }
+    if (seconds === WHAM_SESSION_WINDOW_SECONDS) {
+        return "session";
+    }
+    if (seconds === WHAM_WEEKLY_WINDOW_SECONDS) {
+        return "weekly";
+    }
+    return null;
+}
+/**
+ * 解析 wham/usage 响应。
+ *
+ * 结构 `rate_limit.{primary_window, secondary_window}.{used_percent, limit_window_seconds, reset_at}`，
+ * **按 `limit_window_seconds` 认桶**（18000→5h、604800→7d），不假设 primary/secondary 顺序（与主路径按
+ * `windowDurationMins` 认桶同构）。某窗缺 `used_percent` 跳过、不阻断另一窗；两窗都缺返回全 null。
+ */
+function parseWhamUsage(json) {
+    const rateLimit = isRecord(json) && isRecord(json.rate_limit) ? json.rate_limit : null;
+    if (!rateLimit) {
+        return { fiveHour: null, sevenDay: null, resetsAt: null };
+    }
+    let session = null;
+    let weekly = null;
+    for (const window of [rateLimit.primary_window, rateLimit.secondary_window]) {
+        if (!isRecord(window)) {
+            continue;
+        }
+        if (readWhamUsedPercent(window) === null) {
+            continue; // 某窗缺 used_percent 跳过。
+        }
+        const kind = classifyWhamWindow(toFiniteNumber(window.limit_window_seconds));
+        if (kind === "session" && !session) {
+            session = window;
+        }
+        else if (kind === "weekly" && !weekly) {
+            weekly = window;
+        }
+    }
+    return {
+        fiveHour: readWhamUsedPercent(session),
+        sevenDay: readWhamUsedPercent(weekly),
+        resetsAt: readWhamResetsAtMs(session) ?? readWhamResetsAtMs(weekly),
+    };
+}
+/** 构造一个全 null 的 outcome 占位（wham 内部失败统一用 error）。 */
+function emptyWhamOutcome(status) {
+    return { fiveHour: null, sevenDay: null, resetsAt: null, status };
+}
+/**
+ * wham/usage HTTP 直连回退：读 auth.json 的 chatgpt OAuth token → `GET wham/usage` → parseWhamUsage 认桶。
+ *
+ * 仅在主路径 `unavailable`（本机无 codex CLI）时由 resolveCodexQuota 编排调用。全程不抛错：
+ * 无 token / HTTP 失败 / 非 2xx / JSON 异常 / 解析空 → `{ status: "error", ... }`，成功 → `{ status: "ok", ... }`。
+ * 请求经 api-mode 的 httpRequest（自带统一 env 代理通道，代理环境也能回退采到额度）。
+ */
+async function fetchCodexQuotaViaWham(options = {}) {
+    const env = options.env ?? process.env;
+    const timeoutMs = options.timeoutMs ?? WHAM_TIMEOUT_MS;
+    const authReader = options.authReader ?? readCodexAuth;
+    const httpGet = options.httpGet ?? api_mode_1.httpRequest;
+    const auth = authReader(options.codexHomePath);
+    if (!auth) {
+        (0, debug_1.debugLog)("codex", "wham fallback: no chatgpt auth token");
+        return emptyWhamOutcome("error");
+    }
+    const headers = {
+        Authorization: `Bearer ${auth.accessToken}`,
+        "User-Agent": "codex-cli",
+        Accept: "application/json",
+    };
+    if (auth.accountId) {
+        headers["ChatGPT-Account-Id"] = auth.accountId;
+    }
+    try {
+        const { status, body } = await httpGet(WHAM_USAGE_URL, { method: "GET", headers, timeoutMs }, env);
+        if (status < 200 || status >= 300) {
+            (0, debug_1.debugLog)("codex", "wham fallback non-2xx", { status });
+            return emptyWhamOutcome("error");
+        }
+        let json;
+        try {
+            json = JSON.parse(body);
+        }
+        catch (error) {
+            (0, debug_1.debugLog)("codex", "wham fallback json parse failed", error instanceof Error ? error.message : String(error));
+            return emptyWhamOutcome("error");
+        }
+        const quota = parseWhamUsage(json);
+        (0, debug_1.debugLog)("codex", "wham fallback parsed", quota);
+        return { ...quota, status: "ok" };
+    }
+    catch (error) {
+        (0, debug_1.debugLog)("codex", "wham fallback failed", error instanceof Error ? error.message : String(error));
+        return emptyWhamOutcome("error");
+    }
+}
 /** 同步读取额度缓存；损坏 / 缺失返回 null。 */
 function readCodexQuotaCacheSync(dataDir) {
     try {
@@ -314,22 +473,40 @@ async function resolveCodexQuota(dataDir, options = {}) {
     const now = options.now ?? new Date();
     const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
     const fetcher = options.fetcher ?? fetchCodexQuota;
+    const whamFetcher = options.whamFetcher ?? fetchCodexQuotaViaWham;
     const cached = readCodexQuotaCacheSync(dataDir);
     if (cached && isCodexCacheFresh(cached, ttlMs, now)) {
         return quotaFromCache(cached);
     }
+    const persist = async (quota) => {
+        await writeCodexQuotaCache(dataDir, { ...quota, fetchedAt: now.toISOString() });
+        return quota;
+    };
     try {
         const outcome = await fetcher(options.fetchOptions);
         if (outcome.status === "ok" && hasAnyQuota(outcome)) {
-            const quota = {
-                fiveHour: outcome.fiveHour,
-                sevenDay: outcome.sevenDay,
-                resetsAt: outcome.resetsAt,
-            };
-            await writeCodexQuotaCache(dataDir, { ...quota, fetchedAt: now.toISOString() });
-            return quota;
+            return await persist({ fiveHour: outcome.fiveHour, sevenDay: outcome.sevenDay, resetsAt: outcome.resetsAt });
+        }
+        // 主路径 unavailable（本机无 codex CLI）→ wham/usage HTTP 直连回退；
+        // error（超时 / RPC 错 / 进程崩）不触发，避免瞬时故障多扛一次 15s HTTP。
+        if (outcome.status === "unavailable") {
+            try {
+                const whamOutcome = await whamFetcher({
+                    codexHomePath: options.fetchOptions?.codexHomePath,
+                    env: options.fetchOptions?.env,
+                });
+                if (whamOutcome.status === "ok" && hasAnyQuota(whamOutcome)) {
+                    return await persist({ fiveHour: whamOutcome.fiveHour, sevenDay: whamOutcome.sevenDay, resetsAt: whamOutcome.resetsAt });
+                }
+                (0, debug_1.debugLog)("codex", "wham fallback did not yield usable quota", { status: whamOutcome.status });
+            }
+            catch (error) {
+                (0, debug_1.debugLog)("codex", "wham fallback threw", error instanceof Error ? error.message : String(error));
+            }
+        }
+        else {
+            (0, debug_1.debugLog)("codex", "fetch did not yield usable quota", { status: outcome.status });
         }
-        (0, debug_1.debugLog)("codex", "fetch did not yield usable quota", { status: outcome.status });
     }
     catch (error) {
         (0, debug_1.debugLog)("codex", "fetch threw, fallback to cache", error instanceof Error ? error.message : String(error));

package/dist/lib/dashboard.js

@@ -34,8 +34,8 @@ function summarizeEvents(events) {
     const codexByDesc = events.filter(payload_1.isCodexSourceEvent).sort(byDesc);
     const latestUsagePct = (0, aggregate_1.addNullable)(claudeByDesc.find((event) => event.usagePct !== null)?.usagePct ?? null, codexByDesc.find((event) => event.usagePct !== null)?.usagePct ?? null);
     const latestSevenDayUsagePct = (0, aggregate_1.addNullable)(claudeByDesc.find((event) => event.sevenDayUsagePct !== null)?.sevenDayUsagePct ?? null, codexByDesc.find((event) => event.sevenDayUsagePct !== null)?.sevenDayUsagePct ?? null);
-    // 7d 分区叠加累计：与 aggregate 同一套「去毛刺 + 分段峰谷和」，口径与团队看板一致。
-    const sevenDayCumulativeUsagePct = (0, aggregate_1.computeCumulativeSevenDay)((0, aggregate_1.buildSevenDayCurveFromEvents)(events));
+    // 7d 分源累计：Claude + Codex 各自「去毛刺 + 分段峰谷和」后相加，与 aggregate 同口径（混算会虚高）。
+    const sevenDayCumulativeUsagePct = (0, aggregate_1.addNullable)((0, aggregate_1.computeCumulativeSevenDay)((0, aggregate_1.buildSevenDayCurveFromEvents)(events.filter((event) => !(0, payload_1.isCodexSourceEvent)(event)))), (0, aggregate_1.computeCumulativeSevenDay)((0, aggregate_1.buildSevenDayCurveFromEvents)(events.filter(payload_1.isCodexSourceEvent))));
     return {
         fiveHourLatestUsagePct: latestUsagePct,
         fiveHourPeakUsagePct: usages.length > 0 ? (0, time_1.roundNumber)(Math.max(...usages), 1) : null,
@@ -79,8 +79,9 @@ function bucketizeEvents(events, start, end, bucketMinutes = 5) {
     }
     // 7d 累计曲线（去毛刺 + 分段峰谷和的逐点版本）映射到时间桶：曲线已按时间升序，
     // 同桶内后写覆盖前写，最终每个桶留下落在其区间内最后一个累计点的值（单调，等于桶内最大累计）。
+    // 只画 Claude 源：折线图是 Claude 趋势看板（与同图 5h/7d 两条线同源），Codex 累计已并入顶部 summary 数值。
     const cumulativeByBucket = new Map();
-    for (const point of (0, aggregate_1.computeCumulativeSevenDayCurve)((0, aggregate_1.buildSevenDayCurveFromEvents)(events))) {
+    for (const point of (0, aggregate_1.computeCumulativeSevenDayCurve)((0, aggregate_1.buildSevenDayCurveFromEvents)(events.filter((event) => !(0, payload_1.isCodexSourceEvent)(event))))) {
         const ts = new Date(point.timestamp).getTime();
         if (ts < start.getTime() || ts > end.getTime()) {
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccus-cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Claude Code statusline usage logger and dashboard CLI",
   "type": "commonjs",
   "bin": {
@@ -37,5 +37,9 @@
     "@types/node": "^24.0.0",
     "tsx": "^4.20.0",
     "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "http-proxy-agent": "^9.1.0",
+    "https-proxy-agent": "^9.1.0"
   }
 }