@dougen/dsh-deepseek-usage 0.1.7 → 0.2.1

package/README.md

@@ -2,99 +2,66 @@
 
 DeepSeek 用量侧边栏插件（DeepSeek Harness Web UI）
 
-> **⚠️ 使用须知**
-> - 本插件界面文案仅提供**中文**，无多语言版本。
-> - **仅适用于 DSH 的 Web UI**：命令行等其他非WEB界面不支持。
-> - **今日花费为本地估算值**（非官方账单）：按本地会话日志 token × 官方峰谷价格表计算。
-> - **峰谷时段按北京时间（Asia/Shanghai）固定计算**，与服务器本地时区无关。
-
 ## 简介
 
-给 DeepSeek Harness（DSH）**网页界面**用的插件：在**侧边栏底部**常驻显示你的 **DeepSeek 账号用量**卡片 —— 余额、今日花费、今日 Token、今日 API 调用次数与高峰/空闲计费时段指示灯。
-
-## 界面截图
+在 DSH **网页界面**的侧边栏底部常驻显示你的 **DeepSeek 账号用量**卡片：余额、今日消费金额、今日 Token、今日 API 请求次数，以及高峰/空闲计费时段指示灯。
 
 ![DeepSeek 用量卡片](https://cdn.jsdelivr.net/npm/@dougen/dsh-deepseek-usage/screenshot.png)
 
-侧边栏底部常驻卡片：余额、今日花费、今日 Token、今日 API 次数、峰谷状态灯与当前档单价。
-
 ## 功能
 
 - 第一行：`余额 ¥110.00`
-- 第二行：`今日 ¥2.94 · 36.9M · 170`（今日花费为**本地估算**）
+- 第二行：`今日 2.94 · 36.9M · 170`（今日消费金额 · 今日 Token · 今日 API 请求次数）
 - 第三行：`↑1.5 · 💾0.05 · ↓4.5`（输入 / 缓存命中 / 输出 单价，按当前启用模型与峰谷时段自动切换）
-- 右上角：高峰/空闲状态指示灯（高峰 9:00–12:00、14:00–18:00 **北京时间**为橙色；其余空闲为绿色；悬停提示时段）
-- 每 60 秒自动刷新；点击卡片任意位置也可手动刷新
-- 跟随应用明暗主题（`--dsw-*` 变量，含兜底值）
+- 右上角：高峰/空闲状态指示灯（高峰 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 层。
+安装后重启网页应用：`dsh web`，打开 http://127.0.0.1:3080 ，侧边栏底部（Cordis 面板按钮下方）即出现用量卡片。
 
-本地开发时也可以手动安装：
-
-```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 面板按钮下方）即出现用量卡片。
-
-> 手动方式：把包放进 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 无用量查询接口），覆盖全部会话，含重启前历史 |
+| 余额 | DeepSeek 官方 API `GET /user/balance`（使用 DSH 中已配置的 `DEEPSEEK_API_KEY`） |
+| 今日消费 / Token / API 请求次数 | DeepSeek **开放平台官方账单**（platform.deepseek.com 用量页面数据，约 5 分钟延迟） |
+
+**无需手动配置任何 Token**：插件通过浏览器的调试接口（CDP）自动读取你本机浏览器中 DeepSeek 开放平台的登录状态。首次使用请先在浏览器中登录 [platform.deepseek.com](https://platform.deepseek.com)。
 
-统计口径（v0.1.7 起，与 DSH 官方 token-meter 对齐）：
+> 需要你的浏览器开启**远程调试**（一次性设置，设置后长期有效）：在地址栏打开 `chrome://inspect/#remote-debugging`，勾选"允许远程调试"；或用命令行启动浏览器时加参数 `--remote-debugging-port=9222`。
 
-- **按 (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 一起发给该地址**；仅在你信任该网关/代理时配置。
+1. 点击卡片，浏览器会打开 DeepSeek 开放平台页面
+2. 登录完成后回到 DSH，再次点击卡片（或等待自动刷新）即可显示今日用量
 
-## 变更记录
+## 常见问题
 
-### v0.1.7
+**登录了平台但卡片仍显示未登录？**
+- 请确认登录的是 [platform.deepseek.com](https://platform.deepseek.com)（开放平台），而不是 chat.deepseek.com（网页版对话）。
+- 请确认浏览器已开启远程调试（见上文"数据来源"），设置后可点击卡片强制刷新一次。
+- 支持的浏览器：Chromium 内核（Chromium / Chrome / Edge / CentBrowser 等）。
 
-- **统计口径修正**：按 (turn, step) 去重并吸收流式 usage 样本，失败请求的用量不再漏计（P1）。
-- **性能优化**：按会话修订值增量扫描，只重读变化的会话日志；跨北京日自动失效缓存（P2）。
-- **安全加固**：路由仅接受本机 Host，拦截 DNS rebinding 与局域网访问（P3）。
-- **字段语义修正**：余额响应 `available`（误用官方 `is_available`）改为 `isAvailable` 布尔（P4）。
-- **未知模型提示**：价格表外模型按 chat 档计价并明示，不再静默算错（P5）。
-- **时区修正**：峰谷判定与"今日"边界改为固定北京时间，不随服务器时区漂移（P6）。
-- **依赖声明**：补充 `@deepseek-ai/dsh-host-webserver` peer 依赖（P8）。
+**为什么显示"平台未登录"？**
+- 浏览器未开启远程调试：在地址栏打开 `chrome://inspect/#remote-debugging`，勾选"允许远程调试"后重启浏览器（设置会持久保留）。
+- 或启动浏览器时加参数：`--remote-debugging-port=9222`。
+- 登录状态已过期：点击卡片重新登录即可。
 
-### v0.1.6
+**今日数据与平台页面不一致？**
+- 官方用量数据本身有约 5 分钟延迟，且按北京时间（GMT+8）统计。
 
-- 初始发布（审计基线）。
+**支持哪些浏览器？**
+- Chromium 内核浏览器均可（自动探测本机安装的 Chromium / Chrome / Edge / CentBrowser）。
 
 ## 卸载
 

package/lib/browser-token.js

@@ -0,0 +1,181 @@
+/**
+ * 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 开放平台登录" };
+}

package/lib/client.js

@@ -15,15 +15,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)}`;
+			return n.toFixed(2);
 		}
 
 		function fmtTokens(value) {
@@ -90,11 +89,12 @@ window.__ModuleLoader__.load({
 			const [error, setError] = useState("");
 			const [spinning, setSpinning] = useState(false);
 			const mounted = useRef(true);
+			const retryRef = useRef(null);
 
-			const load = useCallback(async () => {
+			const load = useCallback(async (force) => {
 				setSpinning(true);
 				try {
-					const res = await fetch(USAGE_PATH, { cache: "no-store" });
+					const res = await fetch(USAGE_PATH + (force ? "?refresh=1" : ""), { cache: "no-store" });
 					let body = null;
 					try {
 						body = await res.json();
@@ -116,17 +116,20 @@ window.__ModuleLoader__.load({
 			useEffect(() => {
 				mounted.current = true;
 				load();
-				const timer = setInterval(load, POLL_MS);
+				const timer = setInterval(() => load(false), 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 currency = balance && balance.currency ? balance.currency : "CNY";
 			const errs = (Array.isArray(data && data.errors) ? data.errors : []).concat(error ? [error] : []);
 			const tok = today && today.tokens ? today.tokens : null;
 			const dot = {
@@ -137,7 +140,28 @@ window.__ModuleLoader__.load({
 				background: data && data.peak ? C.peak : C.idle,
 				boxShadow: "0 0 4px rgba(0,0,0,.3)",
 			};
-			const title = "DeepSeek 用量 · 点击刷新" + (errs.length ? " · " + errs.join("; ") : "");
+			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("; ") : "");
 
 			if (!wide) {
 				return h("div", {
@@ -157,9 +181,9 @@ window.__ModuleLoader__.load({
 						userSelect: "none",
 					},
 					title,
-					onClick: load,
+					onClick: handleClick,
 				},
-					h("span", { style: { fontWeight: 700, fontSize: 12, color: C.label } }, money(balance && balance.total, currency)),
+					h("span", { style: { fontWeight: 700, fontSize: 12, color: C.label } }, money(balance && balance.total)),
 					h("span", { style: dot, title: data && data.peak ? "高峰时段" : "空闲时段" }));
 			}
 
@@ -174,7 +198,7 @@ window.__ModuleLoader__.load({
 					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 costText = money(today && today.cost);
 			const costShown = costText;
 
 			return h("div", {
@@ -198,16 +222,19 @@ window.__ModuleLoader__.load({
 					lineHeight: "15px",
 				},
 				title,
-				onClick: load,
+				onClick: handleClick,
 			},
 				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) : "—")),
+					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),
+						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) : "—")),
 				h("span", {
 					style: { position: "absolute", top: 8, right: 9, ...dot },
 					title: data && data.peak ? "高峰时段 " + (data.peakHours || "") : "空闲时段",

package/lib/index.js

@@ -3,50 +3,42 @@
  *
  * 注册一个 HTTP 路由：
  *
- *   GET /api/deepseek-usage
+ *   GET /api/deepseek-usage[?refresh=1]
  *
  * 返回（JSON）：
  *   {
  *     ok: true,
- *     balance: { isAvailable, total, currency, granted, toppedUp },   // 官方余额接口
+ *     balance: { isAvailable, total, currency, granted, toppedUp },  // 官方余额接口（API Key）
  *     today: {
- *       cost,         // 今日花费：本地日志估算（日志 token × 官方峰谷价格表）
- *       costSource: 'estimate' | null,
- *       tokens: { input, output, cacheRead, cacheWrite, total },   // 今日 token 数（本地日志）
- *       calls,        // 今日有用量报告的 API 调用数（本地日志，按 turn/step 去重）
- *       sessions      // 今日有活动的会话数
+ *       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,                                               // 峰谷时段（北京时间）
+ *     tier: { input, cacheRead, cacheWrite, output, model, known },  // 当前模型当前档单价
  *     updatedAt, errors
  *   }
  *
- * 余额来自 DeepSeek 官方 GET /user/balance（API Key 经凭证服务解析，与
- * llm-deepseek 同一引用，不出本机）。今日 Token / API 次数只能从本地会话
- * 日志统计（官方无用量查询接口）；今日花费为本地估算：
- * 日志 token × 官方峰谷价格表（见 lib/pricing.js）。
+ * 数据源：
+ * - 余额：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，前端提示用户
+ *   点击卡片前往登录页。
  *
- * 统计口径（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 绑定下的局域网访问；userToken 仅在进程内存中使用。
  */
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { getPlatformToken } from "./browser-token.js";
 import {
   DEFAULT_MODEL,
   PEAK_HOURS_TEXT,
-  costOf,
   isPeak,
-  shanghaiDayKey,
   startOfTodayShanghaiMs,
   unitAt,
 } from "./pricing.js";
@@ -61,14 +53,26 @@ 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 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));
@@ -105,168 +109,120 @@ 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 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");
 }
 
-function freshAgg() {
-  return { calls: 0, input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, unknownModels: new Set() };
+/** 读取平台登录 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;
 }
 
-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);
+/**
+ * 聚合 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;
 }
 
 /**
- * 顺序扫描一个会话的原始日志，返回该会话的今日聚合；无今日样本返回 null。
- * 与 token-meter 相同的 last-wins 语义：同一 (turn, step) 的 usage 样本
- * （流式 chunk 或最终 message）只计最后一次，绝不重复计数。
+ * 聚合 by_api_key/cost 响应（与平台用量页面同源）。
+ * biz_data = { start, end, bucket, data: [{ currency, series: [{ api_key, model, buckets: [{ time, cost }] }] }] }
+ * 优先取 CNY 币种组（与余额币种一致），无 CNY 时取第一组。
  */
-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;
+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;
     }
-    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;
+  return cost;
 }
 
-let usageCache = null;
-let usageCacheAt = 0;
-let usageCacheDay = "";
-/** sessionId -> { revision, agg }，per-session 增量聚合缓存（P2）。 */
-let sessionAggCache = new Map();
-
 /**
- * 扫描全部会话日志，统计今日（北京时间）token 用量 / API 调用数 / 花费估算。
- * 增量策略：会话修订值（listSnapshots）未变 → 复用缓存聚合；只重读变化的
- * 会话；跨北京日（shanghaiDayKey 变化）时全部失效重扫。
+ * 获取官方今日用量（北京时间今天 00:00–24:00，接口与平台用量页面同源）。
+ * @returns {{ ok: true, tokens, calls, cost } | { authError: true } | { ok: false, error }}
  */
-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 不可用" };
+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)}` };
   }
-  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();
+  if (amountRes.status === 401 || amountRes.status === 403 || costRes.status === 401 || costRes.status === 403) {
+    return { authError: true };
   }
-  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 {}
+  if (!amountRes.ok || !costRes.ok) {
+    return { ok: false, error: `用量接口 HTTP ${amountRes.status}/${costRes.status}` };
+  }
+  let amountBody;
+  let costBody;
   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) {
-      const id = header.id;
-      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);
+    amountBody = await amountRes.json();
+    costBody = await costRes.json();
+  } catch {
+    return { ok: false, error: "用量接口响应解析失败" };
   }
-  acc.cost = Math.round(acc.cost * 1e6) / 1e6;
-  usageCache = acc;
-  usageCacheAt = now;
-  usageCacheDay = dayKey;
-  return acc;
+  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) {
@@ -276,14 +232,15 @@ 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 = [];
+          const refresh = hasRefreshFlag(req);
 
-          // ---- 余额（官方接口）----
+          // ---- 余额（官方接口，API Key）----
           const balance = { isAvailable: null, total: null, currency: null, granted: null, toppedUp: null };
           try {
             const hit = await ctx.credentials.resolve(API_KEY_REF);
@@ -312,13 +269,32 @@ 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(", ")}`);
+          // ---- 今日消费 / 请求次数 / 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 {
@@ -327,29 +303,12 @@ 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,
-            },
+            today,
             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,6 +7,9 @@
  * 与 isKnownModel() 让调用方提示用户，而不是静默算错。
  * 价格调整时只需改 PRICE_TABLE 与 PEAK_WINDOWS。
  *
+ * 本文件仅用于卡片第三行"当前档单价"展示；今日消费金额已直接来自官方账单
+ * （platform.deepseek.com），不再本地按 token×价格估算。
+ *
  * 时区（0.1.7 起）：峰谷判定与"今日"边界一律按北京时间（Asia/Shanghai，
  * 固定 UTC+8，无夏令时）计算，不随服务器本地时区变化——在任何时区部署的
  * DSH 上显示一致。
@@ -79,14 +82,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.7",
-  "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、今日花费（本地日志估算）、今日 Token 与 API 次数（本地日志）、高峰/空闲时段指示灯。",
+  "version": "0.2.1",
+  "description": "DeepSeek 用量侧边栏插件：余额（官方 API）、今日消费金额/Token/API 请求次数（官方账单，自动获取浏览器登录态）、高峰/空闲时段指示灯。",
   "type": "module",
   "main": "lib/index.js",
   "files": [