@dougen/dsh-deepseek-usage 0.1.8 → 0.3.0

package/README.md

@@ -2,103 +2,47 @@
 
 DeepSeek 用量侧边栏插件（DeepSeek Harness Web UI）
 
-> **⚠️ 使用须知**
-> - 本插件界面文案仅提供**中文**，无多语言版本。
-> - **仅适用于 DSH 的 Web UI**：命令行等其他非WEB界面不支持。
-> - **今日花费为本地估算值**（非官方账单）：按本地会话日志 token × 官方峰谷价格表计算。
-> - **峰谷时段按北京时间（Asia/Shanghai）固定计算**，与服务器本地时区无关。
-
 ## 简介
 
-给 DeepSeek Harness（DSH）**网页界面**用的插件：在**侧边栏底部**常驻显示你的 **DeepSeek 账号用量**卡片 —— 余额、今日花费、今日 Token、今日 API 调用次数与高峰/空闲计费时段指示灯。
-
-## 界面截图
+在 DSH **网页界面**的侧边栏底部常驻显示你的 **DeepSeek 账号余额**（放大显示）与**当前模型档单价**卡片，并提供高峰/空闲计费时段指示灯。
 
 ![DeepSeek 用量卡片](https://cdn.jsdelivr.net/npm/@dougen/dsh-deepseek-usage/screenshot.png)
 
-侧边栏底部常驻卡片：余额、今日花费、今日 Token、今日 API 次数、峰谷状态灯与当前档单价。
-
 ## 功能
 
-- 第一行：`余额 ¥110.00`
-- 第二行：`今日 ¥2.94 · 36.9M · 170`（今日花费为**本地估算**）
-- 第三行：`↑1.5 · 💾0.05 · ↓4.5`（输入 / 缓存命中 / 输出 单价，按当前启用模型与峰谷时段自动切换）
-- 右上角：高峰/空闲状态指示灯（高峰 9:00–12:00、14:00–18:00 **北京时间**为橙色；其余空闲为绿色；悬停提示时段）
-- 每 60 秒自动刷新；点击卡片任意位置也可手动刷新
-- 跟随应用明暗主题（`--dsw-*` 变量，含兜底值）
+- **余额**：`¥ 110.00` 大字显示（符号随账号币种自动切换：人民币 `¥` / 美元 `$`）
+- **档单价**：`↑¥1.50 · 💾¥0.05 · ↓¥4.50`（输入 / 输入缓存 / 输出，随当前启用模型与峰谷时段自动切换，符号跟随余额币种）
+- **峰谷指示灯**：卡片右上角，高峰（9:00–12:00、14:00–18:00 北京时间）橙色，空闲绿色
+- **自动刷新**：每 5 分钟一次；点击卡片任意位置立即刷新，刷新时右下角显示旋转图标
+- 跟随应用明暗主题
 
 ## 安装
 
-需要 DSH CLI。**从 npm 直接安装（推荐）**：
+需要 DSH CLI，从 npm 安装：
 
 ```sh
 dsh plugin --profile web add @dougen/dsh-deepseek-usage
 ```
 
-> 包声明了 `dsh.bundle`，`dsh plugin` 会自动把它加入 profile 的 bundle 层。
-
-本地开发时也可以手动安装：
-
-```sh
-cd dsh-deepseek-usage
-pnpm pack                                       # 生成 dougen-dsh-deepseek-usage-<version>.tgz
-dsh plugin --profile web add <生成的 .tgz>
-```
-
-安装之后：
-
-1. 重启网页应用：`dsh web`（bundle 层在启动时读取）。
-2. 打开 http://127.0.0.1:3080 。
-3. 侧边栏底部（Cordis 面板按钮下方）即出现用量卡片。
+安装后重启网页应用：`dsh web`，打开 http://127.0.0.1:3080 ，侧边栏底部（Cordis 面板按钮下方）即出现用量卡片。
 
-> 手动方式：把包放进 profile 的 `node_modules`，并在 `~/.dsh/profiles/web/cordis.patch.yml` 追加：
->
-> ```yaml
-> - insert:
->     - id: deepseek-usage
->       name: @dougen/dsh-deepseek-usage
-> ```
-
-## 数据来源与统计口径
+## 数据来源
 
 | 数据 | 来源 |
 |---|---|
-| 余额 | DeepSeek 官方 `GET /user/balance`（API Key 经凭证服务 `DEEPSEEK_API_KEY` 解析，不出本机） |
-| 今日花费 | **本地估算**：本地会话日志 token × 官方峰谷价格表（非官方账单） |
-| 今日 Token / API 调用数 | 本地会话日志统计（官方 API 无用量查询接口），覆盖全部会话，含重启前历史 |
-
-统计口径（v0.1.7 起，与 DSH 官方 token-meter 对齐）：
-
-- **按 (turn, step) 去重**：同一调用的流式 usage 与最终消息只计一次，绝不重复计数；
-- **失败请求的用量也计入**：请求失败、没有最终消息时，流式 usage 样本仍被统计；
-- **今日 = 北京时间（Asia/Shanghai）**的自然日，与服务器时区无关；
-- 模型不在内置价格表时按 `deepseek-chat` 档计价，并在卡片错误提示中明示（避免静默算错）。
-
-## 安全说明
-
-- 用量路由 `GET /api/deepseek-usage` **仅接受本机 Host**（`127.0.0.1` / `localhost` / `::1`），可拦截 DNS rebinding 与局域网直接访问。
-- ⚠️ 若将 DSH 配置为 `host: 0.0.0.0` 对外网开放，本插件会在入口拒绝非本机 Host 的请求，但**请勿依赖插件作为唯一防线**——余额为账号敏感信息，建议用反向代理 + 鉴权保护整个 DSH 服务。
-- ⚠️ 环境变量 `DEEPSEEK_BASE_URL`（与 llm-deepseek 适配器对齐）会把余额请求与 **API Key 一起发给该地址**；仅在你信任该网关/代理时配置。
-
-## 变更记录
-
-### v0.1.8
-
-- **修复 0.1.7 回归：今日用量统计全为 0**。根因：`listSnapshots()` 返回的会话条目是 `{ header: SessionHeader, revision }`，id 位于 `header.id` 嵌套字段；0.1.7 误取顶层 `header.id`（undefined），导致所有会话 `readRaw` 失败被跳过（skipped>0、统计为 0）。已修正并从真实会话日志端到端验证：统计恢复、无读取失败。
+| 余额 | DeepSeek 官方 API `GET /user/balance`（使用 DSH 中已配置的 `DEEPSEEK_API_KEY`） |
+| 档单价 / 峰谷时段 | 内置价格表（DeepSeek 官方峰谷定价快照，2026-08-17 起） |
 
-### v0.1.7
+使用前请确保 DSH 已配置 `DEEPSEEK_API_KEY`（可在 DSH 设置中的模型页面配置）。
 
-- **统计口径修正**：按 (turn, step) 去重并吸收流式 usage 样本，失败请求的用量不再漏计（P1）。
-- **性能优化**：按会话修订值增量扫描，只重读变化的会话日志；跨北京日自动失效缓存（P2）。
-- **安全加固**：路由仅接受本机 Host，拦截 DNS rebinding 与局域网访问（P3）。
-- **字段语义修正**：余额响应 `available`（误用官方 `is_available`）改为 `isAvailable` 布尔（P4）。
-- **未知模型提示**：价格表外模型按 chat 档计价并明示，不再静默算错（P5）。
-- **时区修正**：峰谷判定与"今日"边界改为固定北京时间，不随服务器时区漂移（P6）。
-- **依赖声明**：补充 `@deepseek-ai/dsh-host-webserver` peer 依赖（P8）。
+## 常见问题
 
-### v0.1.6
+**余额显示"—"？**
+- 未配置 `DEEPSEEK_API_KEY`：在 DSH 设置中配置后重启。
+- 网络或接口异常：错误信息会显示在卡片下方。
 
-- 初始发布（审计基线）。
+**单价与官方价格不一致？**
+- 单价按**当前启用模型**与**峰谷时段**自动切换；若当前模型不在内置价格表，会按 `deepseek-chat` 档展示并给出提示。
 
 ## 卸载
 

package/lib/client.js

@@ -2,7 +2,8 @@
 //
 // 侧边栏底部用量卡片（注册进 `sidebar.footer.action` 槽位，独占一行，位于
 // Cordis 面板按钮下方）。轮询宿主路由 `/api/deepseek-usage`（见 lib/index.js）
-// 每 60 秒一次，点击卡片任意位置可立即刷新；右下角在刷新时显示旋转 ⟳ 图标，仅作刷新状态指示（无更新时间显示）。
+// 每 5 分钟一次，点击卡片任意位置可立即刷新；右下角在刷新时显示旋转 ⟳ 图标。
+// 卡片显示：余额（放大显示，人民币符号）+ 当前模型档单价（输入/输入缓存/输出）。
 // 样式仅使用 `--dsw-*` 主题变量（含兜底值），跟随明暗主题。
 window.__ModuleLoader__.load({
 	id: "@dougen/dsh-deepseek-usage",
@@ -15,23 +16,14 @@ window.__ModuleLoader__.load({
 		const h = react.createElement;
 
 		// ---- constants -------------------------------------------------
-		const POLL_MS = 60 * 1000;
+		const POLL_MS = 5 * 60 * 1000;
 		const USAGE_PATH = "/api/deepseek-usage";
 
 		// ---- helpers ---------------------------------------------------
-		function money(value, currency) {
+		function money(value) {
 			const n = Number(value);
 			if (!Number.isFinite(n)) return "—";
-			const symbol = currency === "USD" ? "$" : "¥";
-			return `${symbol}${n.toFixed(2)}`;
-		}
-
-		function fmtTokens(value) {
-			const n = Number(value);
-			if (!Number.isFinite(n)) return "—";
-			if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
-			if (n >= 1e3) return (n / 1e3).toFixed(1) + "k";
-			return String(n);
+			return n.toFixed(2);
 		}
 
 		function fmtPrice(value) {
@@ -60,18 +52,8 @@ window.__ModuleLoader__.load({
 			strokeWidth: 2.2,
 			strokeLinecap: "round",
 			strokeLinejoin: "round",
-			style: { flex: "none", color: C.sub },
+			style: { flex: "none", display: "block" },
 		};
-		const IconMoney = () => h("svg", svgBase,
-			h("circle", { cx: 12, cy: 12, r: 9 }),
-			h("path", { d: "M12 6.5v11" }),
-			h("path", { d: "M9 9.5h6" }),
-			h("path", { d: "M9 14.5h6" }));
-		const IconToken = () => h("svg", svgBase,
-			h("rect", { x: 6.5, y: 6.5, width: 11, height: 11, rx: 2 }),
-			h("path", { d: "M9 2.5v4M15 2.5v4M9 17.5v4M15 17.5v4" }),
-			h("path", { d: "M2.5 9h4M2.5 15h4M17.5 9h4M17.5 15h4" }));
-		const IconApi = () => h("svg", svgBase, h("path", { d: "M13 2 3 14h7l-1 8 10-12h-7l1-8z" }));
 		const IconIn = () => h("svg", svgBase,
 			h("path", { d: "M12 19V5" }),
 			h("path", { d: "M5 12l7-7 7 7" }));
@@ -124,11 +106,9 @@ window.__ModuleLoader__.load({
 			}, [load]);
 
 			const balance = data && data.balance ? data.balance : null;
-			const today = data && data.today ? data.today : null;
 			const tier = data && data.tier ? data.tier : null;
-			const currency = balance && balance.currency ? balance.currency : "CNY";
+			const symbol = balance && balance.currency === "USD" ? "$" : "¥";
 			const errs = (Array.isArray(data && data.errors) ? data.errors : []).concat(error ? [error] : []);
-			const tok = today && today.tokens ? today.tokens : null;
 			const dot = {
 				width: 8,
 				height: 8,
@@ -159,23 +139,17 @@ window.__ModuleLoader__.load({
 					title,
 					onClick: load,
 				},
-					h("span", { style: { fontWeight: 700, fontSize: 12, color: C.label } }, money(balance && balance.total, currency)),
+					h("span", { style: { display: "inline-flex", alignItems: "baseline", gap: 3 } },
+						h("span", { style: { fontWeight: 700, fontSize: 13, color: C.label } }, symbol),
+						h("span", { style: { fontWeight: 700, fontSize: 13, color: C.label } }, money(balance && balance.total))),
 					h("span", { style: dot, title: data && data.peak ? "高峰时段" : "空闲时段" }));
 			}
 
-			const grp = (label, icon, value) =>
-				h("span", { style: { display: "inline-flex", gap: 2, alignItems: "center", minWidth: 0 } },
-					label ? h("span", { style: { color: C.sub, fontSize: 11, marginRight: 5 } }, label) : null,
-					h("span", { style: { display: "inline-flex", alignItems: "center" } }, icon),
-					h("span", { style: { fontWeight: 600, whiteSpace: "nowrap" } }, value));
-			const pr = (icon, value) =>
-				h("span", { style: { display: "inline-flex", gap: 2, alignItems: "center" } },
-					h("span", { style: { display: "inline-flex", alignItems: "center" } }, icon),
-					h("span", { style: { fontWeight: 600, whiteSpace: "nowrap" } }, value));
-			const Sep = () => h("span", { style: { color: C.sub, margin: "0 1px", fontSize: 10 } }, "·");
-
-			const costText = money(today && today.cost, currency);
-			const costShown = costText;
+			const Price = (icon, label, value) =>
+				h("span", { style: { display: "inline-flex", alignItems: "center", gap: 3, minWidth: 0, color: C.sub } },
+					h("span", { style: { display: "inline-flex", alignItems: "center" }, title: label }, icon),
+					h("span", { style: { fontWeight: 600, whiteSpace: "nowrap" } }, symbol + fmtPrice(value)));
+			const Sep = () => h("span", { style: { color: C.sub, margin: "0 3px", fontSize: 10 } }, "·");
 
 			return h("div", {
 				style: {
@@ -200,40 +174,30 @@ window.__ModuleLoader__.load({
 				title,
 				onClick: load,
 			},
-				h("div", { style: { display: "flex", alignItems: "baseline", minWidth: 0, paddingRight: 12 } },
-					grp("余额", h(IconMoney, null), money(balance && balance.total, currency))),
-				h("div", { style: { display: "flex", gap: 4, alignItems: "center", minWidth: 0, flexWrap: "nowrap" } },
-					grp("今日", h(IconMoney, null), costShown),
-					Sep(),
-					grp(null, h(IconToken, null), fmtTokens(tok && tok.total)),
-					Sep(),
-					grp(null, h(IconApi, null), today && today.calls !== null && today.calls !== undefined ? String(today.calls) : "—")),
+				// 第一行：余额（24px，符号与数字 3px 间距）+ 当前档单价（灰色，跟在余额后，字号不变）
+				h("div", { style: { display: "flex", alignItems: "baseline", minWidth: 0, paddingRight: 14, gap: 6 } },
+					h("span", { style: { fontWeight: 700, fontSize: 24, color: C.label, lineHeight: "28px", marginRight: 3 } }, symbol),
+					h("span", { style: { fontWeight: 700, fontSize: 24, color: C.label, lineHeight: "28px" } }, money(balance && balance.total)),
+					h("span", { style: { display: "inline-flex", alignItems: "center", gap: 3, marginLeft: 10 } },
+						Price(h(IconIn, null), "输入", tier && tier.input),
+						Sep(),
+						Price(h(IconCache, null), "输入缓存", tier && tier.cacheRead),
+						Sep(),
+						Price(h(IconOut, null), "输出", tier && tier.output))),
 				h("span", {
 					style: { position: "absolute", top: 8, right: 9, ...dot },
 					title: data && data.peak ? "高峰时段 " + (data.peakHours || "") : "空闲时段",
 				}),
-				h("div", { style: { display: "flex", alignItems: "center", justifyContent: "space-between", gap: 8, minWidth: 0 } },
-					tier
-						? h("span", { style: { display: "inline-flex", gap: 4, alignItems: "center", color: C.sub, fontSize: 10, whiteSpace: "nowrap", overflow: "hidden" } },
-							h("span", { style: { color: C.sub, fontSize: 10, marginRight: 4 } }, "价格"),
-							pr(h(IconIn, null), fmtPrice(tier.input)),
-							Sep(),
-							pr(h(IconCache, null), fmtPrice(tier.cacheRead)),
-							Sep(),
-							pr(h(IconOut, null), fmtPrice(tier.output)))
-						: null,
-					h("span", {
-						className: "dsw-usage-time",
-						style: { display: "inline-flex", alignItems: "center", gap: 4, color: C.sub, fontSize: 10, flex: "none" },
-					},
-						spinning
-							? h("span", {
-								className: "dsw-usage-refresh",
-								style: { color: C.label, display: "inline-flex", alignItems: "center" },
-								title: "刷新中",
-							}, h("svg", { width: 11, height: 11, viewBox: "0 0 16 16", fill: "none", style: { animation: "dsh-usage-spin .8s linear infinite" } },
-								h("path", { d: "M13.5 8a5.5 5.5 0 1 1-1.6-3.9M13.5 1.5v3h-3", stroke: "currentColor", strokeWidth: 1.6, strokeLinecap: "round", strokeLinejoin: "round" })))
-							: null)),
+				// 刷新指示：卡片右下角
+				h("span", {
+					className: "dsw-usage-refresh",
+					style: { position: "absolute", bottom: 8, right: 9, display: "inline-flex", alignItems: "center", color: C.sub },
+					title: "刷新中",
+				},
+					spinning
+						? h("svg", { width: 11, height: 11, viewBox: "0 0 16 16", fill: "none", style: { animation: "dsh-usage-spin .8s linear infinite" } },
+							h("path", { d: "M13.5 8a5.5 5.5 0 1 1-1.6-3.9M13.5 1.5v3h-3", stroke: "currentColor", strokeWidth: 1.6, strokeLinecap: "round", strokeLinejoin: "round" }))
+						: null),
 				errs.length
 					? h("div", { style: { color: C.err, fontSize: 10, whiteSpace: "pre-wrap" } }, errs.join(" | "))
 					: null);

package/lib/index.js

@@ -8,46 +8,24 @@
  * 返回（JSON）：
  *   {
  *     ok: true,
- *     balance: { isAvailable, total, currency, granted, toppedUp },   // 官方余额接口
- *     today: {
- *       cost,         // 今日花费：本地日志估算（日志 token × 官方峰谷价格表）
- *       costSource: 'estimate' | null,
- *       tokens: { input, output, cacheRead, cacheWrite, total },   // 今日 token 数（本地日志）
- *       calls,        // 今日有用量报告的 API 调用数（本地日志，按 turn/step 去重）
- *       sessions      // 今日有活动的会话数
- *     },
- *     peak, peakHours,                                              // 峰谷时段（北京时间）
- *     tier: { input, cacheRead, cacheWrite, output, model, known }, // 当前模型当前档单价
+ *     balance: { isAvailable, total, currency, granted, toppedUp },  // 官方余额接口（API Key）
+ *     tier: { input, cacheRead, cacheWrite, output, model, known },  // 当前模型当前档单价
+ *     peak, peakHours,                                               // 峰谷时段（北京时间）
  *     updatedAt, errors
  *   }
  *
- * 余额来自 DeepSeek 官方 GET /user/balance（API Key 经凭证服务解析，与
- * llm-deepseek 同一引用，不出本机）。今日 Token / API 次数只能从本地会话
- * 日志统计（官方无用量查询接口）；今日花费为本地估算：
- * 日志 token × 官方峰谷价格表（见 lib/pricing.js）。
+ * 数据源：余额来自 DeepSeek 官方 GET /user/balance（API Key 经凭证服务解析，
+ * 与 llm-deepseek 同一引用，不出本机）。单价与峰谷时段来自内置价格表
+ * （lib/pricing.js，DeepSeek 官方峰谷定价快照）。
  *
- * 统计口径（0.1.7 起，与 DSH 官方 token-meter 对齐）：
- * - 按 (turn, step) 去重：同一调用的流式 usage chunk 与最终 assistant/message
- *   只计一次，后者覆盖前者（last-wins）；
- * - 同时吸收 assistant/chunk 的 usage 样本，因此"请求失败、没有最终
- *   assistant/message"的调用其用量仍被计入（chunk 样本存活）；
- * - calls = 今日有用量报告的唯一调用数（近似 API 请求数，含失败请求）。
- *
- * 性能（0.1.7 起）：按会话增量扫描——持久化后端会话修订值
- * （listSnapshots）未变的会话复用缓存的聚合结果，只重读变化的会话；
- * 跨北京日自动失效全部缓存。
- *
- * 安全（0.1.7 起）：路由仅接受 Host 为 127.0.0.1 / localhost / ::1 的请求，
- * 拒绝 DNS rebinding 与 0.0.0.0 绑定下的局域网访问。
+ * 安全：路由仅接受本机 Host（127.0.0.1 / localhost / ::1），拦截 DNS
+ * rebinding 与 0.0.0.0 绑定下的局域网访问。
  */
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import {
   DEFAULT_MODEL,
   PEAK_HOURS_TEXT,
-  costOf,
   isPeak,
-  shanghaiDayKey,
-  startOfTodayShanghaiMs,
   unitAt,
 } from "./pricing.js";
 
@@ -61,8 +39,6 @@ const API_KEY_REF = credentialRef("DEEPSEEK_API_KEY");
 const BALANCE_PATH = "/user/balance";
 const ROUTE_PATH = "/api/deepseek-usage";
 const TIMEOUT_MS = 15000;
-/** 本地用量扫描的短缓存，避免多标签页/轮询反复解码全部日志。 */
-const USAGE_CACHE_MS = 20000;
 
 const JSON_HEADERS = {
   "content-type": "application/json; charset=utf-8",
@@ -105,173 +81,6 @@ function isLocalHost(req) {
   return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
 
-/**
- * (turn, step) 去重键：同一调用的 usage chunk 与最终 message 共享 key，
- * 后者覆盖前者；缺少 turn/step 时退化为按事件 seq 独立计（罕见，日志
- * 规范下不该发生）。
- */
-function stepKey(turn, step, seq) {
-  if (typeof turn === "number" && typeof step === "number") return `t:${turn}:s:${step}`;
-  return `e:${seq}`;
-}
-
-function freshAgg() {
-  return { calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, unknownModels: new Set() };
-}
-
-function addAgg(target, src) {
-  target.calls += src.calls;
-  target.input += src.input;
-  target.output += src.output;
-  target.cacheRead += src.cacheRead;
-  target.cacheWrite += src.cacheWrite;
-  target.cost += src.cost;
-  for (const m of src.unknownModels) target.unknownModels.add(m);
-}
-
-/**
- * 顺序扫描一个会话的原始日志，返回该会话的今日聚合；无今日样本返回 null。
- * 与 token-meter 相同的 last-wins 语义：同一 (turn, step) 的 usage 样本
- * （流式 chunk 或最终 message）只计最后一次，绝不重复计数。
- */
-function scanSessionRaw(content, dayStart, fallbackModel) {
-  const agg = freshAgg();
-  const steps = new Map();
-  for (const line of content.split("\n")) {
-    if (line === "") continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (event === null || typeof event !== "object" || typeof event.time !== "number" || event.time < dayStart) continue;
-    const data = event.data;
-    if (data === null || typeof data !== "object") continue;
-    let usage;
-    let model;
-    if (
-      event.type === "assistant/chunk" &&
-      data.chunk !== null &&
-      typeof data.chunk === "object" &&
-      data.chunk.type === "usage" &&
-      data.chunk.usage
-    ) {
-      // 流式 usage 样本：失败请求没有最终 message 时仍存活，必须计入。
-      usage = data.chunk.usage;
-      model = fallbackModel;
-    } else if (event.type === "assistant/message" && data.usage) {
-      // 最终样本：覆盖同 (turn, step) 的早期 chunk 样本。
-      usage = data.usage;
-      const source = data.message && data.message.source;
-      model = source && typeof source.model === "string" ? source.model : fallbackModel;
-    } else {
-      continue;
-    }
-    steps.set(stepKey(data.turn, data.step, event.seq), { usage, model, time: event.time });
-  }
-  if (steps.size === 0) return null;
-  for (const { usage, model, time } of steps.values()) {
-    const unit = unitAt(model, time);
-    if (!unit.known) agg.unknownModels.add(model);
-    agg.calls += 1;
-    agg.input += usage.inputTokens || 0;
-    agg.output += usage.outputTokens || 0;
-    agg.cacheRead += usage.cacheReadTokens || 0;
-    agg.cacheWrite += usage.cacheWriteTokens || 0;
-    agg.cost += costOf(usage, unit);
-  }
-  return agg;
-}
-
-let usageCache = null;
-let usageCacheAt = 0;
-let usageCacheDay = "";
-/** sessionId -> { revision, agg }，per-session 增量聚合缓存（P2）。 */
-let sessionAggCache = new Map();
-
-/**
- * 扫描全部会话日志，统计今日（北京时间）token 用量 / API 调用数 / 花费估算。
- * 增量策略：会话修订值（listSnapshots）未变 → 复用缓存聚合；只重读变化的
- * 会话；跨北京日（shanghaiDayKey 变化）时全部失效重扫。
- */
-async function scanTodayUsage(ctx) {
-  const persistence = ctx.get("sessionPersistence");
-  if (persistence === void 0 || typeof persistence.list !== "function" || typeof persistence.readRaw !== "function") {
-    return { usable: false, error: "sessionPersistence 不可用" };
-  }
-  const now = Date.now();
-  const dayKey = shanghaiDayKey(now);
-  if (usageCache !== null && usageCacheDay === dayKey && now - usageCacheAt < USAGE_CACHE_MS) return usageCache;
-  if (usageCacheDay !== dayKey) {
-    usageCacheDay = dayKey;
-    sessionAggCache.clear();
-  }
-  const dayStart = startOfTodayShanghaiMs(now);
-  const acc = freshAgg();
-  acc.usable = true;
-  acc.sessions = 0;
-  acc.skipped = 0;
-  let defaultModel = DEFAULT_MODEL;
-  try {
-    const adm = ctx.get("agentDefaultModel");
-    const selection = adm && typeof adm.currentSelection === "function" ? adm.currentSelection() : void 0;
-    if (selection && typeof selection.model === "string") defaultModel = selection.model;
-  } catch {}
-  try {
-    const hasSnapshots = typeof persistence.listSnapshots === "function";
-    const headers = hasSnapshots ? await persistence.listSnapshots() : await persistence.list();
-    const seen = new Set();
-    for (const header of headers) {
-      // listSnapshots 返回 { header: SessionHeader, revision }，id 在 header.header.id；
-      // list 直接返回 SessionHeader[]（顶层 id）。
-      const id = hasSnapshots ? header.header.id : header.id;
-      if (typeof id !== "string" || id === "") continue;
-      seen.add(id);
-      const revision = hasSnapshots ? header.revision : void 0;
-      const cached = sessionAggCache.get(id);
-      if (cached !== void 0 && revision !== void 0 && cached.revision === revision) {
-        if (cached.agg !== null) {
-          addAgg(acc, cached.agg);
-          acc.sessions += 1;
-        }
-        continue;
-      }
-      let raw;
-      try {
-        raw = await persistence.readRaw(id);
-      } catch {
-        acc.skipped += 1;
-        sessionAggCache.delete(id);
-        continue;
-      }
-      if (raw === void 0 || raw === null || typeof raw.content !== "string") {
-        sessionAggCache.delete(id);
-        continue;
-      }
-      const agg = scanSessionRaw(raw.content, dayStart, defaultModel);
-      sessionAggCache.set(id, { revision, agg });
-      if (agg === null) continue;
-      addAgg(acc, agg);
-      acc.sessions += 1;
-    }
-    if (hasSnapshots) {
-      // 修剪已被删除的会话缓存。
-      for (const id of sessionAggCache.keys()) {
-        if (!seen.has(id)) sessionAggCache.delete(id);
-      }
-    }
-  } catch (error) {
-    acc.usable = false;
-    acc.error = error instanceof Error ? error.message : String(error);
-  }
-  acc.cost = Math.round(acc.cost * 1e6) / 1e6;
-  usageCache = acc;
-  usageCacheAt = now;
-  usageCacheDay = dayKey;
-  return acc;
-}
-
 function apply(ctx) {
   ctx.effect(
     () => ctx.webServer.register({
@@ -279,14 +88,14 @@ function apply(ctx) {
       path: ROUTE_PATH,
       handler: async (req, res) => {
         try {
-          // ---- 仅本机访问（P3）：拦截 DNS rebinding 与局域网直接访问 ----
+          // ---- 仅本机访问：拦截 DNS rebinding 与局域网直接访问 ----
           if (!isLocalHost(req)) {
             return sendJson(res, 403, { ok: false, error: "forbidden", message: "仅允许本机访问" });
           }
 
           const errors = [];
 
-          // ---- 余额（官方接口）----
+          // ---- 余额（官方接口，API Key）----
           const balance = { isAvailable: null, total: null, currency: null, granted: null, toppedUp: null };
           try {
             const hit = await ctx.credentials.resolve(API_KEY_REF);
@@ -315,13 +124,7 @@ function apply(ctx) {
             errors.push(`余额获取失败: ${error instanceof Error ? error.message : String(error)}`);
           }
 
-          // ---- 今日 token / API 调用数 / 花费估算（本地日志）----
-          const usage = await scanTodayUsage(ctx);
-          if (!usage.usable) errors.push(usage.error ?? "今日用量统计不可用");
-          if (usage.usable && usage.unknownModels.size > 0) {
-            errors.push(`未知模型按 chat 档计价: ${[...usage.unknownModels].join(", ")}`);
-          }
-
+          // ---- 当前模型当前档单价 + 峰谷（展示用）----
           const now = Date.now();
           let model = DEFAULT_MODEL;
           try {
@@ -330,29 +133,11 @@ function apply(ctx) {
             if (selection && typeof selection.model === "string") model = selection.model;
           } catch {}
           const unit = unitAt(model, now);
-
-          const cost = usage.usable ? usage.cost : null;
-          const costSource = usage.usable ? "estimate" : null;
+          if (!unit.known) errors.push(`当前模型 ${model} 不在价格表，档单价按 deepseek-chat 展示`);
 
           sendJson(res, 200, {
             ok: true,
             balance,
-            today: {
-              cost,
-              costSource,
-              tokens: usage.usable
-                ? {
-                    input: usage.input,
-                    output: usage.output,
-                    cacheRead: usage.cacheRead,
-                    cacheWrite: usage.cacheWrite,
-                    total: usage.input + usage.output + usage.cacheRead + usage.cacheWrite,
-                  }
-                : null,
-              calls: usage.usable ? usage.calls : null,
-              sessions: usage.usable ? usage.sessions : null,
-              skipped: usage.usable ? usage.skipped : null,
-            },
             peak: isPeak(now),
             peakHours: PEAK_HOURS_TEXT,
             tier: {

package/lib/pricing.js

@@ -1,5 +1,5 @@
 /**
- * dsh-deepseek-usage — 定价引擎（元 / 百万 tokens）。
+ * dsh-deepseek-usage — 定价表（元 / 百万 tokens）。
  *
  * DeepSeek 官方价格快照（2026-08-17 起 V4 系列峰谷定价，北京时间）：
  * 高峰时段 9:00–12:00 与 14:00–18:00（北京时间），其余为空闲时段（空闲=高峰半价）。
@@ -7,9 +7,10 @@
  * 与 isKnownModel() 让调用方提示用户，而不是静默算错。
  * 价格调整时只需改 PRICE_TABLE 与 PEAK_WINDOWS。
  *
- * 时区（0.1.7 起）：峰谷判定与"今日"边界一律按北京时间（Asia/Shanghai，
- * 固定 UTC+8，无夏令时）计算，不随服务器本地时区变化——在任何时区部署的
- * DSH 上显示一致。
+ * 本文件用于卡片"当前档单价"展示与峰谷指示灯。
+ *
+ * 时区（0.1.7 起）：峰谷判定按北京时间（Asia/Shanghai，固定 UTC+8，无夏令时）
+ * 计算，不随服务器本地时区变化——在任何时区部署的 DSH 上显示一致。
  */
 
 /** 北京时间固定偏移（上海无夏令时）。 */
@@ -36,21 +37,6 @@ export function shanghaiHour(ms) {
   return new Date(ms + SHANGHAI_OFFSET_MS).getUTCHours();
 }
 
-/** 某时刻所在北京日的零点（unix ms）。 */
-export function startOfTodayShanghaiMs(now) {
-  const shifted = new Date(now + SHANGHAI_OFFSET_MS);
-  return Date.UTC(shifted.getUTCFullYear(), shifted.getUTCMonth(), shifted.getUTCDate()) - SHANGHAI_OFFSET_MS;
-}
-
-/** 某时刻所在北京日的日期键（YYYY-MM-DD），用于跨日失效。 */
-export function shanghaiDayKey(now) {
-  const shifted = new Date(now + SHANGHAI_OFFSET_MS);
-  const y = shifted.getUTCFullYear();
-  const m = String(shifted.getUTCMonth() + 1).padStart(2, '0');
-  const d = String(shifted.getUTCDate()).padStart(2, '0');
-  return `${y}-${m}-${d}`;
-}
-
 /** 某时刻是否为高峰时段（按北京时间）。 */
 export function isPeak(ms) {
   const h = shanghaiHour(ms);
@@ -79,14 +65,3 @@ export function unitAt(model, ms) {
     known,
   };
 }
-
-/** 按单位价格计算一次 usage 的估算成本（元）。 */
-export function costOf(usage, unit) {
-  return (
-    (usage.inputTokens * unit.input +
-      (usage.cacheReadTokens || 0) * unit.cacheRead +
-      (usage.cacheWriteTokens || 0) * unit.cacheWrite +
-      usage.outputTokens * unit.output) /
-    1e6
-  );
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dougen/dsh-deepseek-usage",
-  "version": "0.1.8",
-  "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、今日花费（本地日志估算）、今日 Token 与 API 次数（本地日志）、高峰/空闲时段指示灯。",
+  "version": "0.3.0",
+  "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、当前档单价与峰谷时段指示灯。",
   "type": "module",
   "main": "lib/index.js",
   "files": [