@dougen/dsh-deepseek-usage 0.2.1 → 0.3.0

package/README.md

@@ -4,17 +4,16 @@ DeepSeek 用量侧边栏插件（DeepSeek Harness Web UI）
 
 ## 简介
 
-在 DSH **网页界面**的侧边栏底部常驻显示你的 **DeepSeek 账号用量**卡片：余额、今日消费金额、今日 Token、今日 API 请求次数，以及高峰/空闲计费时段指示灯。
+在 DSH **网页界面**的侧边栏底部常驻显示你的 **DeepSeek 账号余额**（放大显示）与**当前模型档单价**卡片，并提供高峰/空闲计费时段指示灯。
 
 ![DeepSeek 用量卡片](https://cdn.jsdelivr.net/npm/@dougen/dsh-deepseek-usage/screenshot.png)
 
 ## 功能
 
-- 第一行：`余额 ¥110.00`
-- 第二行：`今日 2.94 · 36.9M · 170`（今日消费金额 · 今日 Token · 今日 API 请求次数）
-- 第三行：`↑1.5 · 💾0.05 · ↓4.5`（输入 / 缓存命中 / 输出 单价，按当前启用模型与峰谷时段自动切换）
-- 右上角：高峰/空闲状态指示灯（高峰 9:00–12:00、14:00–18:00 北京时间，橙色；其余空闲，绿色）
-- 每 5 分钟自动刷新；点击卡片任意位置可立即刷新
+- **余额**：`¥ 110.00` 大字显示（符号随账号币种自动切换：人民币 `¥` / 美元 `$`）
+- **档单价**：`↑¥1.50 · 💾¥0.05 · ↓¥4.50`（输入 / 输入缓存 / 输出，随当前启用模型与峰谷时段自动切换，符号跟随余额币种）
+- **峰谷指示灯**：卡片右上角，高峰（9:00–12:00、14:00–18:00 北京时间）橙色，空闲绿色
+- **自动刷新**：每 5 分钟一次；点击卡片任意位置立即刷新，刷新时右下角显示旋转图标
 - 跟随应用明暗主题
 
 ## 安装
@@ -32,36 +31,18 @@ dsh plugin --profile web add @dougen/dsh-deepseek-usage
 | 数据 | 来源 |
 |---|---|
 | 余额 | DeepSeek 官方 API `GET /user/balance`（使用 DSH 中已配置的 `DEEPSEEK_API_KEY`） |
-| 今日消费 / Token / API 请求次数 | DeepSeek **开放平台官方账单**（platform.deepseek.com 用量页面数据，约 5 分钟延迟） |
+| 档单价 / 峰谷时段 | 内置价格表（DeepSeek 官方峰谷定价快照，2026-08-17 起） |
 
-**无需手动配置任何 Token**：插件通过浏览器的调试接口（CDP）自动读取你本机浏览器中 DeepSeek 开放平台的登录状态。首次使用请先在浏览器中登录 [platform.deepseek.com](https://platform.deepseek.com)。
-
-> 需要你的浏览器开启**远程调试**（一次性设置，设置后长期有效）：在地址栏打开 `chrome://inspect/#remote-debugging`，勾选"允许远程调试"；或用命令行启动浏览器时加参数 `--remote-debugging-port=9222`。
-
-### 未登录时
-
-如果检测不到平台登录，卡片第二行会显示 **`平台未登录，点击卡片进行登录`**：
-
-1. 点击卡片，浏览器会打开 DeepSeek 开放平台页面
-2. 登录完成后回到 DSH，再次点击卡片（或等待自动刷新）即可显示今日用量
+使用前请确保 DSH 已配置 `DEEPSEEK_API_KEY`（可在 DSH 设置中的模型页面配置）。
 
 ## 常见问题
 
-**登录了平台但卡片仍显示未登录？**
-- 请确认登录的是 [platform.deepseek.com](https://platform.deepseek.com)（开放平台），而不是 chat.deepseek.com（网页版对话）。
-- 请确认浏览器已开启远程调试（见上文"数据来源"），设置后可点击卡片强制刷新一次。
-- 支持的浏览器：Chromium 内核（Chromium / Chrome / Edge / CentBrowser 等）。
-
-**为什么显示"平台未登录"？**
-- 浏览器未开启远程调试：在地址栏打开 `chrome://inspect/#remote-debugging`，勾选"允许远程调试"后重启浏览器（设置会持久保留）。
-- 或启动浏览器时加参数：`--remote-debugging-port=9222`。
-- 登录状态已过期：点击卡片重新登录即可。
-
-**今日数据与平台页面不一致？**
-- 官方用量数据本身有约 5 分钟延迟，且按北京时间（GMT+8）统计。
+**余额显示"—"？**
+- 未配置 `DEEPSEEK_API_KEY`：在 DSH 设置中配置后重启。
+- 网络或接口异常：错误信息会显示在卡片下方。
 
-**支持哪些浏览器？**
-- Chromium 内核浏览器均可（自动探测本机安装的 Chromium / Chrome / Edge / CentBrowser）。
+**单价与官方价格不一致？**
+- 单价按**当前启用模型**与**峰谷时段**自动切换；若当前模型不在内置价格表，会按 `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",
@@ -25,14 +26,6 @@ window.__ModuleLoader__.load({
 			return 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);
-		}
-
 		function fmtPrice(value) {
 			const n = Number(value);
 			if (!Number.isFinite(n)) return "—";
@@ -59,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" }));
@@ -89,12 +72,11 @@ window.__ModuleLoader__.load({
 			const [error, setError] = useState("");
 			const [spinning, setSpinning] = useState(false);
 			const mounted = useRef(true);
-			const retryRef = useRef(null);
 
-			const load = useCallback(async (force) => {
+			const load = useCallback(async () => {
 				setSpinning(true);
 				try {
-					const res = await fetch(USAGE_PATH + (force ? "?refresh=1" : ""), { cache: "no-store" });
+					const res = await fetch(USAGE_PATH, { cache: "no-store" });
 					let body = null;
 					try {
 						body = await res.json();
@@ -116,22 +98,17 @@ window.__ModuleLoader__.load({
 			useEffect(() => {
 				mounted.current = true;
 				load();
-				const timer = setInterval(() => load(false), POLL_MS);
+				const timer = setInterval(load, POLL_MS);
 				return () => {
 					mounted.current = false;
 					clearInterval(timer);
-					if (retryRef.current) {
-						clearInterval(retryRef.current);
-						retryRef.current = null;
-					}
 				};
 			}, [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 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,
@@ -140,28 +117,7 @@ window.__ModuleLoader__.load({
 				background: data && data.peak ? C.peak : C.idle,
 				boxShadow: "0 0 4px rgba(0,0,0,.3)",
 			};
-			const loggedIn = !!(today && today.platform && today.platform.loggedIn);
-			const loginHint = (today && today.platform && today.platform.loginHint) || "平台未登录，点击卡片进行登录";
-			const handleClick = useCallback(() => {
-				if (loggedIn) {
-					load(true);
-					return;
-				}
-				// 未登录：打开 DeepSeek 开放平台登录页，并短暂高频重试等待登录完成。
-				if (typeof window !== "undefined") window.open("https://platform.deepseek.com", "_blank");
-				load(true);
-				if (retryRef.current) return;
-				let tries = 0;
-				retryRef.current = setInterval(() => {
-					tries += 1;
-					load(true);
-					if (tries >= 6) {
-						clearInterval(retryRef.current);
-						retryRef.current = null;
-					}
-				}, 10000);
-			}, [loggedIn, load]);
-			const title = "DeepSeek 用量 · " + (loggedIn ? "点击刷新" : "点击登录") + (errs.length ? " · " + errs.join("; ") : "");
+			const title = "DeepSeek 用量 · 点击刷新" + (errs.length ? " · " + errs.join("; ") : "");
 
 			if (!wide) {
 				return h("div", {
@@ -181,25 +137,19 @@ window.__ModuleLoader__.load({
 						userSelect: "none",
 					},
 					title,
-					onClick: handleClick,
+					onClick: load,
 				},
-					h("span", { style: { fontWeight: 700, fontSize: 12, color: C.label } }, money(balance && balance.total)),
+					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);
-			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: {
@@ -222,45 +172,32 @@ window.__ModuleLoader__.load({
 					lineHeight: "15px",
 				},
 				title,
-				onClick: handleClick,
+				onClick: load,
 			},
-				h("div", { style: { display: "flex", alignItems: "baseline", minWidth: 0, paddingRight: 12 } },
-					grp("余额", h(IconMoney, null), money(balance && balance.total))),
-				!loggedIn
-					? h("div", { style: { display: "flex", alignItems: "center", minWidth: 0, color: C.err, fontWeight: 600, gap: 4 } },
-						h("span", { style: { overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" } }, loginHint))
-					: h("div", { style: { display: "flex", gap: 4, alignItems: "center", minWidth: 0, flexWrap: "nowrap" } },
-						grp("今日", h(IconMoney, null), costShown),
+				// 第一行：余额（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(),
-						grp(null, h(IconToken, null), fmtTokens(tok && tok.total)),
+						Price(h(IconCache, null), "输入缓存", tier && tier.cacheRead),
 						Sep(),
-						grp(null, h(IconApi, null), today && today.calls !== null && today.calls !== undefined ? String(today.calls) : "—")),
+						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

@@ -3,43 +3,29 @@
  *
  * 注册一个 HTTP 路由：
  *
- *   GET /api/deepseek-usage[?refresh=1]
+ *   GET /api/deepseek-usage
  *
  * 返回（JSON）：
  *   {
  *     ok: true,
  *     balance: { isAvailable, total, currency, granted, toppedUp },  // 官方余额接口（API Key）
- *     today: {
- *       cost, costSource: 'official' | null,                         // 今日消费金额（官方账单）
- *       tokens: { input, output, cacheRead, cacheWrite, total },     // 今日 token（官方账单）
- *       calls,                                                       // 今日 API 请求次数（官方账单）
- *       platform: { loggedIn, loginHint? }                           // 平台登录态
- *     },
- *     peak, peakHours,                                               // 峰谷时段（北京时间）
  *     tier: { input, cacheRead, cacheWrite, output, model, known },  // 当前模型当前档单价
+ *     peak, peakHours,                                               // 峰谷时段（北京时间）
  *     updatedAt, errors
  *   }
  *
- * 数据源：
- * - 余额：DeepSeek 官方 GET /user/balance（API Key 经凭证服务解析，与 llm-deepseek
- *   同一引用，不出本机）。
- * - 今日消费/请求次数/tokens：platform.deepseek.com 官方账单接口
- *   （/api/v0/usage/amount|cost?month=&year=），登录态 userToken 由
- *   lib/browser-token.js 自动从本机浏览器 Local Storage 读取，无需用户配置。
- *   页面数据按 GMT+8，官方提示约 5 分钟延迟。
- * - 未检测到平台登录或登录过期：today.platform.loggedIn = false，前端提示用户
- *   点击卡片前往登录页。
+ * 数据源：余额来自 DeepSeek 官方 GET /user/balance（API Key 经凭证服务解析，
+ * 与 llm-deepseek 同一引用，不出本机）。单价与峰谷时段来自内置价格表
+ * （lib/pricing.js，DeepSeek 官方峰谷定价快照）。
  *
  * 安全：路由仅接受本机 Host（127.0.0.1 / localhost / ::1），拦截 DNS
- * rebinding 与 0.0.0.0 绑定下的局域网访问；userToken 仅在进程内存中使用。
+ * rebinding 与 0.0.0.0 绑定下的局域网访问。
  */
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
-import { getPlatformToken } from "./browser-token.js";
 import {
   DEFAULT_MODEL,
   PEAK_HOURS_TEXT,
   isPeak,
-  startOfTodayShanghaiMs,
   unitAt,
 } from "./pricing.js";
 
@@ -54,25 +40,11 @@ const BALANCE_PATH = "/user/balance";
 const ROUTE_PATH = "/api/deepseek-usage";
 const TIMEOUT_MS = 15000;
 
-const PLATFORM_BASE = "https://platform.deepseek.com";
-const PLATFORM_USAGE_HEADERS = {
-  Accept: "application/json",
-  Referer: "https://platform.deepseek.com/usage",
-  Origin: "https://platform.deepseek.com",
-};
-/** userToken 内存缓存时长（浏览器 Local Storage 读取有复制开销，缓存避免高频重读）。 */
-const PLATFORM_TOKEN_CACHE_MS = 60000;
-
-const LOGIN_HINT = "平台未登录，点击卡片进行登录";
-const LOGIN_EXPIRED_HINT = "平台登录已过期，点击卡片重新登录";
-
 const JSON_HEADERS = {
   "content-type": "application/json; charset=utf-8",
   "cache-control": "no-store",
 };
 
-let tokenCache = { token: null, at: 0 };
-
 function sendJson(res, status, body) {
   res.writeHead(status, JSON_HEADERS);
   res.end(JSON.stringify(body));
@@ -109,122 +81,6 @@ function isLocalHost(req) {
   return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
 
-function hasRefreshFlag(req) {
-  const url = req.url ?? "";
-  const q = url.indexOf("?");
-  if (q === -1) return false;
-  return url.slice(q + 1).split("&").some((kv) => kv === "refresh=1");
-}
-
-/** 读取平台登录 token（带短缓存；refresh 时强制重读浏览器）。 */
-async function resolvePlatformToken(force) {
-  const now = Date.now();
-  if (!force && tokenCache.token !== null && now - tokenCache.at < PLATFORM_TOKEN_CACHE_MS) {
-    return tokenCache.token;
-  }
-  const result = await getPlatformToken();
-  if (result.token) {
-    tokenCache = { token: result.token, at: now };
-    return result.token;
-  }
-  tokenCache = { token: null, at: now };
-  return null;
-}
-
-/**
- * 聚合 by_api_key/amount 响应（与平台用量页面同源）。
- * biz_data = { start, end, bucket, models, series: [{ api_key, model, buckets: [{ time, usage: { REQUEST, PROMPT_CACHE_HIT_TOKEN, PROMPT_CACHE_MISS_TOKEN, RESPONSE_TOKEN } }] }] }
- */
-function aggregateByApiKeyAmount(bizData) {
-  const acc = { input: 0, cacheRead: 0, output: 0, requests: 0 };
-  const series = bizData && Array.isArray(bizData.series) ? bizData.series : [];
-  for (const s of series) {
-    for (const b of s.buckets || []) {
-      const u = b && b.usage;
-      if (!u) continue;
-      acc.input += Number(u.PROMPT_CACHE_MISS_TOKEN) || 0;
-      acc.cacheRead += Number(u.PROMPT_CACHE_HIT_TOKEN) || 0;
-      acc.output += Number(u.RESPONSE_TOKEN) || 0;
-      acc.requests += Number(u.REQUEST) || 0;
-    }
-  }
-  return acc;
-}
-
-/**
- * 聚合 by_api_key/cost 响应（与平台用量页面同源）。
- * biz_data = { start, end, bucket, data: [{ currency, series: [{ api_key, model, buckets: [{ time, cost }] }] }] }
- * 优先取 CNY 币种组（与余额币种一致），无 CNY 时取第一组。
- */
-function aggregateByApiKeyCost(bizData) {
-  const groups = bizData && Array.isArray(bizData.data) ? bizData.data : [];
-  const group = groups.find((g) => g && g.currency === "CNY") || groups[0];
-  let cost = 0;
-  for (const s of (group && group.series) || []) {
-    for (const b of s.buckets || []) {
-      cost += Number(b && b.cost) || 0;
-    }
-  }
-  return cost;
-}
-
-/**
- * 获取官方今日用量（北京时间今天 00:00–24:00，接口与平台用量页面同源）。
- * @returns {{ ok: true, tokens, calls, cost } | { authError: true } | { ok: false, error }}
- */
-async function fetchOfficialToday(token) {
-  const dayStart = Math.floor(startOfTodayShanghaiMs(Date.now()) / 1000);
-  const dayEnd = dayStart + 86400;
-  const headers = { ...PLATFORM_USAGE_HEADERS, Authorization: `Bearer ${token}` };
-  let amountRes;
-  let costRes;
-  try {
-    [amountRes, costRes] = await Promise.all([
-      fetch(`${PLATFORM_BASE}/api/v0/usage/by_api_key/amount?start=${dayStart}&end=${dayEnd}&tz=28800`, {
-        headers,
-        signal: AbortSignal.timeout(TIMEOUT_MS),
-      }),
-      fetch(`${PLATFORM_BASE}/api/v0/usage/by_api_key/cost?start=${dayStart}&end=${dayEnd}&tz=28800`, {
-        headers,
-        signal: AbortSignal.timeout(TIMEOUT_MS),
-      }),
-    ]);
-  } catch (error) {
-    return { ok: false, error: `用量接口请求失败: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  if (amountRes.status === 401 || amountRes.status === 403 || costRes.status === 401 || costRes.status === 403) {
-    return { authError: true };
-  }
-  if (!amountRes.ok || !costRes.ok) {
-    return { ok: false, error: `用量接口 HTTP ${amountRes.status}/${costRes.status}` };
-  }
-  let amountBody;
-  let costBody;
-  try {
-    amountBody = await amountRes.json();
-    costBody = await costRes.json();
-  } catch {
-    return { ok: false, error: "用量接口响应解析失败" };
-  }
-  if (amountBody.code === 40002 || amountBody.code === 40003 || costBody.code === 40002 || costBody.code === 40003) {
-    return { authError: true };
-  }
-  const amounts = aggregateByApiKeyAmount(amountBody && amountBody.data && amountBody.data.biz_data);
-  const cost = aggregateByApiKeyCost(costBody && costBody.data && costBody.data.biz_data);
-  return {
-    ok: true,
-    tokens: {
-      input: Math.round(amounts.input),
-      cacheRead: Math.round(amounts.cacheRead),
-      cacheWrite: 0,
-      output: Math.round(amounts.output),
-      total: Math.round(amounts.input + amounts.cacheRead + amounts.output),
-    },
-    calls: Math.round(amounts.requests),
-    cost: Math.round(cost * 1e6) / 1e6,
-  };
-}
-
 function apply(ctx) {
   ctx.effect(
     () => ctx.webServer.register({
@@ -238,7 +94,6 @@ function apply(ctx) {
           }
 
           const errors = [];
-          const refresh = hasRefreshFlag(req);
 
           // ---- 余额（官方接口，API Key）----
           const balance = { isAvailable: null, total: null, currency: null, granted: null, toppedUp: null };
@@ -269,32 +124,7 @@ function apply(ctx) {
             errors.push(`余额获取失败: ${error instanceof Error ? error.message : String(error)}`);
           }
 
-          // ---- 今日消费 / 请求次数 / tokens（官方账单，登录态自动获取）----
-          let today = { cost: null, costSource: null, tokens: null, calls: null, platform: { loggedIn: false, loginHint: LOGIN_HINT } };
-          const token = await resolvePlatformToken(refresh);
-          if (token === null) {
-            today.platform = { loggedIn: false, loginHint: LOGIN_HINT };
-          } else {
-            const usage = await fetchOfficialToday(token);
-            if (usage.authError) {
-              // 登录过期：清缓存，下次重读浏览器（用户重新登录后自动恢复）。
-              tokenCache = { token: null, at: Date.now() };
-              today.platform = { loggedIn: false, loginHint: LOGIN_EXPIRED_HINT };
-            } else if (usage.ok) {
-              today = {
-                cost: usage.cost,
-                costSource: "official",
-                tokens: usage.tokens,
-                calls: usage.calls,
-                platform: { loggedIn: true },
-              };
-            } else {
-              today.platform = { loggedIn: true };
-              errors.push(usage.error);
-            }
-          }
-
-          // ---- 当前模型当前档单价（展示用）----
+          // ---- 当前模型当前档单价 + 峰谷（展示用）----
           const now = Date.now();
           let model = DEFAULT_MODEL;
           try {
@@ -308,7 +138,6 @@ function apply(ctx) {
           sendJson(res, 200, {
             ok: true,
             balance,
-            today,
             peak: isPeak(now),
             peakHours: PEAK_HOURS_TEXT,
             tier: {

package/lib/pricing.js

@@ -7,12 +7,10 @@
  * 与 isKnownModel() 让调用方提示用户，而不是静默算错。
  * 价格调整时只需改 PRICE_TABLE 与 PEAK_WINDOWS。
  *
- * 本文件仅用于卡片第三行"当前档单价"展示；今日消费金额已直接来自官方账单
- * （platform.deepseek.com），不再本地按 token×价格估算。
+ * 本文件用于卡片"当前档单价"展示与峰谷指示灯。
  *
- * 时区（0.1.7 起）：峰谷判定与"今日"边界一律按北京时间（Asia/Shanghai，
- * 固定 UTC+8，无夏令时）计算，不随服务器本地时区变化——在任何时区部署的
- * DSH 上显示一致。
+ * 时区（0.1.7 起）：峰谷判定按北京时间（Asia/Shanghai，固定 UTC+8，无夏令时）
+ * 计算，不随服务器本地时区变化——在任何时区部署的 DSH 上显示一致。
  */
 
 /** 北京时间固定偏移（上海无夏令时）。 */
@@ -39,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);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dougen/dsh-deepseek-usage",
-  "version": "0.2.1",
-  "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、今日消费金额/Token/API 请求次数（官方账单，自动获取浏览器登录态）、高峰/空闲时段指示灯。",
+  "version": "0.3.0",
+  "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、当前档单价与峰谷时段指示灯。",
   "type": "module",
   "main": "lib/index.js",
   "files": [

package/lib/browser-token.js

@@ -1,181 +0,0 @@
-/**
- * dsh-deepseek-usage — 本机浏览器登录态读取（零第三方依赖）。
- *
- * 通过 Chromium 系浏览器的 DevTools 调试服务（CDP，WebSocket）读取运行中
- * 浏览器里 platform.deepseek.com 的登录态 userToken，无需用户手动配置。
- *
- * 工作原理：
- * 1. 从候选浏览器的 User Data 目录读取 DevToolsActivePort 文件（浏览器开启
- *    远程调试时生成），得到调试端口与 WebSocket 路径；
- * 2. 用 Node 内置 WebSocket 连接浏览器级调试会话；
- * 3. 在 platform.deepseek.com 页面 target 上执行 Runtime.evaluate 读取
- *    localStorage 中的 userToken（仅读取，不执行任何写入）；
- * 4. 浏览器中没有该页面时自动创建一个（保留复用，读取后续登录状态）。
- *
- * 实现仅使用 Node 内置能力（WebSocket / fetch / fs），无第三方依赖；
- * 需要 Node 22+（原生 WebSocket）。
- *
- * 安全：token 仅在进程内存中使用，绝不落盘、不出本机（只用于向
- * platform.deepseek.com 官方接口发起 Bearer 认证请求）。
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const PLATFORM_URL = "https://platform.deepseek.com";
-/** userToken 值的最小合理长度（防御性过滤误匹配）。 */
-const MIN_TOKEN_LEN = 20;
-/** 单个 CDP 请求超时。 */
-const RPC_TIMEOUT_MS = 8000;
-/** createTarget 后等待页面加载的时长。 */
-const PAGE_LOAD_WAIT_MS = 3000;
-
-/** %LOCALAPPDATA% 下候选 Chromium 系浏览器的 User Data 目录（按优先级）。 */
-function userDataDirs() {
-  const local = process.env.LOCALAPPDATA;
-  if (!local) return [];
-  return ["Chromium", "CentBrowser", "Google\\Chrome", "Microsoft\\Edge"]
-    .map((b) => join(local, b, "User Data"))
-    .filter((p) => existsSync(p));
-}
-
-/** 读取一个 User Data 目录的 DevToolsActivePort，返回 { port, wsPath } 或 null。 */
-function readDevToolsEndpoint(userData) {
-  const file = join(userData, "DevToolsActivePort");
-  if (!existsSync(file)) return null;
-  try {
-    const lines = readFileSync(file, "utf8").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-    const port = Number(lines[0]);
-    if (!Number.isInteger(port) || port <= 0 || port > 65535 || !lines[1]) return null;
-    return { port, wsPath: lines[1] };
-  } catch {
-    return null;
-  }
-}
-
-let conn = null; // { endpoint, ws, id, pending }
-
-/** 连接浏览器级调试会话（复用已有连接，端口/路径变化时重连）。 */
-async function connect(endpoint) {
-  if (conn && conn.endpoint.port === endpoint.port && conn.endpoint.wsPath === endpoint.wsPath && conn.ws.readyState === 1) {
-    return conn;
-  }
-  if (conn && conn.ws) {
-    try { conn.ws.close(); } catch {}
-    conn = null;
-  }
-  const ws = new WebSocket(`ws://127.0.0.1:${endpoint.port}${endpoint.wsPath}`);
-  const opened = await Promise.race([
-    new Promise((res) => { ws.onopen = () => res(true); }),
-    new Promise((res) => { ws.onerror = () => res(false); }),
-    new Promise((res) => setTimeout(() => res(false), 5000)),
-  ]);
-  if (!opened) {
-    try { ws.close(); } catch {}
-    return null;
-  }
-  conn = { endpoint, ws, id: 0, pending: new Map() };
-  ws.onmessage = (ev) => {
-    let msg;
-    try { msg = JSON.parse(ev.data); } catch { return; }
-    if (msg && msg.id && conn && conn.pending.has(msg.id)) {
-      const { resolve, timer } = conn.pending.get(msg.id);
-      conn.pending.delete(msg.id);
-      clearTimeout(timer);
-      resolve(msg);
-    }
-  };
-  ws.onclose = () => { conn = null; };
-  return conn;
-}
-
-/** 发送一条 CDP 命令，返回响应消息或 { timeout: true }。 */
-function send(conn, method, params, sessionId) {
-  const mid = ++conn.id;
-  const payload = sessionId !== undefined
-    ? { id: mid, sessionId, method, params }
-    : { id: mid, method, params };
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      if (conn.pending.has(mid)) {
-        conn.pending.delete(mid);
-        resolve({ timeout: true });
-      }
-    }, RPC_TIMEOUT_MS);
-    conn.pending.set(mid, { resolve, timer });
-    try {
-      conn.ws.send(JSON.stringify(payload));
-    } catch (e) {
-      clearTimeout(timer);
-      conn.pending.delete(mid);
-      resolve({ error: { message: e.message } });
-    }
-  });
-}
-
-/** 在指定 target 上执行表达式，返回结果值（仅读取操作）。 */
-async function evalOnTarget(conn, targetId, expression) {
-  const att = await send(conn, "Target.attachToTarget", { targetId, flatten: true });
-  if (att.timeout || att.error || !att.result || !att.result.sessionId) return { error: "attach failed" };
-  const sessionId = att.result.sessionId;
-  try {
-    const ev = await send(conn, "Runtime.evaluate", { expression, returnByValue: true }, sessionId);
-    if (ev.timeout || ev.error) return { error: "evaluate failed" };
-    const value = ev.result && ev.result.result ? ev.result.result.value : undefined;
-    return { value: value === undefined ? null : value };
-  } finally {
-    await send(conn, "Target.detachFromTarget", { sessionId }).catch(() => {});
-  }
-}
-
-/** 找到已打开的 platform 页面 target；没有则创建一个（保留复用）。 */
-async function resolvePlatformTarget(conn) {
-  const r = await send(conn, "Target.getTargets");
-  const infos = (r.result && r.result.targetInfos) || [];
-  const existing = infos.find((t) => t.type === "page" && t.url.startsWith(PLATFORM_URL));
-  if (existing) return existing.targetId;
-  const created = await send(conn, "Target.createTarget", { url: PLATFORM_URL });
-  if (created.timeout || created.error || !created.result || !created.result.targetId) return null;
-  const targetId = created.result.targetId;
-  // 等待页面完成加载后再读取。
-  await new Promise((res) => setTimeout(res, PAGE_LOAD_WAIT_MS));
-  return targetId;
-}
-
-/** 从一个浏览器调试端点读取 platform userToken；失败返回 null。 */
-async function readTokenFromEndpoint(endpoint) {
-  const c = await connect(endpoint);
-  if (!c) return null;
-  const targetId = await resolvePlatformTarget(c);
-  if (!targetId) return null;
-  const expression =
-    `(() => { try { const v = localStorage.getItem("userToken"); ` +
-    `if (!v) return null; return JSON.parse(v).value || null; } catch (e) { return null; } })()`;
-  const r = await evalOnTarget(c, targetId, expression);
-  return r && typeof r.value === "string" && r.value.length >= MIN_TOKEN_LEN ? r.value : null;
-}
-
-/**
- * 获取 platform.deepseek.com 的登录态 userToken。
- * 对偶发的调试服务不可用做有限重试，避免误报"未登录"。
- * @returns {{ token: string } | { error: string }}
- */
-export async function getPlatformToken() {
-  if (typeof WebSocket !== "function") {
-    return { error: "当前 Node 版本不支持 WebSocket，无法读取浏览器登录态" };
-  }
-  const attempts = [0, 1];
-  for (const attempt of attempts) {
-    if (attempt > 0) await new Promise((res) => setTimeout(res, 800));
-    for (const ud of userDataDirs()) {
-      const endpoint = readDevToolsEndpoint(ud);
-      if (!endpoint) continue;
-      try {
-        const token = await readTokenFromEndpoint(endpoint);
-        if (token) return { token };
-      } catch {
-        // 该浏览器调试端点不可用，尝试下一个。
-      }
-    }
-  }
-  return { error: "未检测到 DeepSeek 开放平台登录" };
-}