@duke-dsh-plugins/dsh-token-stats 1.5.5 → 1.7.0

package/README.md

@@ -61,11 +61,13 @@ dsh plugin --profile web add https://github.com/MoonlitDropOfBlood/dsh-token-sta
 4. **会话输入框工具行**（model 选择器左侧）内联显示当前 provider 的套餐余额：
    - DeepSeek / OpenRouter 显示余额（如 `¥43.97` / `$12.50`）；
    - MiniMax / Kimi / 智谱 显示 `5h X% | 7d Y%`（5 小时 / 7 天窗口已用百分比，悬停查看重置时间）；
-   - 小米 MiMo 显示 `套餐 X% | 本月 Y%`（Token Plan 已用百分比，悬停查看重置时间；需在凭据里配 platform.xiaomimimo.com 的登录 Cookie，见下）；
+   - 小米 MiMo 默认显示 `今日 X · 7d Y`（**本地用量统计，零凭据、永不过期**）；若在「套餐余额」里填了 dashboard 登录 Cookie，则升级为官方 `剩余 X%` + 周重置倒计时（见下）；
    - 切换模型时自动切换 provider；每 60s 自动刷新，**点击读数立即强制刷新**；
    - 未配置对应 API Key 或拉取失败时显示 `⚠`（悬停查看原因）；当前 provider 不在支持列表时不占位。
 
-> **MiMo（小米）配置**：MiMo 的用量走 dashboard admin API（非公开 endpoint），纯 API Key（Bearer）实测会被 401 拒绝，可靠凭证是浏览器登录 Cookie。打开 platform.xiaomimimo.com → 订阅管理，F12 → Network 任一 `/api/v1/tokenPlan/*` 请求 → 复制完整 `Cookie` 请求头值，粘到 DSH 凭据的 `XIAOMI_MIMO_COOKIE`（或把 API Key 配到 `XIAOMI_MIMO_API_KEY`，插件会先 Bearer 后 Cookie 自动重试）。按 route 派生命名的凭据（设置页自动生成，如 `XIAOMI_TOKEN_PLAN_CN_API_KEY`）同样识别；composer 读数按 route id 匹配（`xiaomi-mimo` / `xiaomimimo` / `xiaomi-token-plan-cn` / 名字含 xiaomi 或 mimo 均可）。**v1.5.4 起也可以直接在「设置 → Token 统计 → 套餐余额 → 凭据设置」里粘贴保存**，无需手改凭据库（mimo 写入 `XIAOMI_MIMO_COOKIE`，不影响 LLM 路由的 API Key）。
+> **MiMo（小米）配置**：**默认零配置**——读数来自本插件自己的会话日志聚合（今日 / 近 7 天消耗 token 数），不发任何 MiMo 请求、不会过期。缺点是拿不到套餐百分比（官方没开放任何 API Key 配额接口：`token-plan-*` 与 `api.` 主机只有 OpenAI 兼容的 `/v1` 推理 API，实测所有 Bearer 配额路径均 404；key 还与区域强绑定，CN key 在 SGP/AMS 主机一律 401）。
+>
+> 想要**官方剩余用量百分比**，唯一路径是 dashboard 账号会话：打开 platform.xiaomimimo.com 登录后，F12 → Network 任一 `/api/v1/*` 请求 → 复制完整 `Cookie` 请求头（含 `api-platform_serviceToken` 与 `userId`）→ 粘到「设置 → Token 统计 → 套餐余额 → **MiMo 官方剩余用量（可选）**」保存（写入 `XIAOMI_MIMO_COOKIE`）。插件内置最小 cookie jar：服务端若在响应里 `Set-Cookie` 续发会话会被自动吸收并写回凭据库（跨轮询、跨重启生效）；**Cookie 彻底失效时自动静默退回本地用量，不会报错**。composer 读数按 route id 匹配（`xiaomi-mimo` / `xiaomimimo` / `xiaomi-token-plan-cn` / 名字含 xiaomi 或 mimo 均可）。
 
 ## 工作原理
 
@@ -88,7 +90,7 @@ TokenStatsService.getQuota()   ← ctx.remote.tokenStats.getQuota(provider, forc
 - 数据按**本地日历天** × **模型**（`provider::model`）聚合；`total = input + output + cacheRead + cacheWrite`。
 - 历史回填只统计插件启动前发生的调用，实时监听只统计启动后的，两者通过每个会话的事件序号水位线合并，不会重复。
 - 模型/模型来自 `assistant/message` 的 `message.source`（kind = 'model'），无需自行解析请求头。
-- 套餐余额：Host 半经 `credentials` 服务解析用户在模型设置里已配置的 API Key（引用命名遵循 `<ROUTE>_API_KEY` 约定），GET provider 官方端点（宿主全局 fetch 优先，无 fetch 时回退 `subprocess` curl）；30s 缓存 + 失败指数退避（5s→30min），不落盘。
+- 套餐余额：Host 半经 `credentials` 服务解析用户在模型设置里已配置的 API Key（引用命名遵循 `<ROUTE>_API_KEY` 约定），GET provider 官方端点（宿主全局 fetch 优先，无 fetch 时回退 `subprocess` curl）；30s 缓存 + 失败指数退避（5s→30min），不落盘。**小米 MiMo 是例外**：它没有 API Key 配额接口，默认用本地会话日志聚合出用量，填了 dashboard Cookie 才升级为官方剩余用量 %。
 
 ## 目录结构
 

package/client.js

@@ -18,8 +18,16 @@
  * (`ctx.remote.tokenStats.getStats()/getQuota()`), published by the Host half
  * in `index.js`.
  */
+/**
+ * This package's client-module id. It is both the `__ModuleLoader__.load` id and
+ * the HMR style owner (`data-plugin`) — client-modules keys style ownership off the
+ * registered id, so the two must stay the same string. See the `claimStyles` note
+ * where the stylesheet is created.
+ */
+const CLIENT_BUNDLE_ID = "@duke-dsh-plugins/dsh-token-stats";
+
 window.__ModuleLoader__.load({
-  id: "@duke-dsh-plugins/dsh-token-stats",
+  id: CLIENT_BUNDLE_ID,
   factory: (require) => {
     var module = { exports: {} };
     var exports = module.exports;
@@ -260,6 +268,13 @@ window.__ModuleLoader__.load({
       try {
         styleTag = document.createElement("style");
         styleTag.textContent = CSS;
+        // dsh 0.2.0 client-modules runs `claimStyles(ownerId)` during
+        // materialization, which claims every *untagged* <style> in the document
+        // for the materializing package. `apply()` is async and appends this tag
+        // after that sweep, so without an explicit owner it would stay untagged
+        // and a later package could adopt it — and `removeOwnedStyles(thatId)`
+        // would then strip our stylesheet on its HMR invalidation. Claim it now.
+        styleTag.setAttribute("data-plugin", CLIENT_BUNDLE_ID);
         document.head.appendChild(styleTag);
         ctx.effect(() => () => styleTag && styleTag.remove());
       } catch (e) {
@@ -667,9 +682,11 @@ window.__ModuleLoader__.load({
         if (lower.includes("mimo") || lower.includes("xiaomi")) return "mimo";
         return null;
       }
-      // 凭据设置行写入的 ref — 与 host QUOTA_PROVIDERS.refs 首选项对齐。
-      // mimo 写 XIAOMI_MIMO_COOKIE（README 文档路径），不触碰 LLM 路由的
-      // API Key ref（host probe 顺序 Cookie 优先，v1.5.4）。
+      // 凭据设置行写入的 ref — 与 host QUOTA_PROVIDERS.apiKeyRefs 首选项对齐。
+      // mimo 写 XIAOMI_MIMO_COOKIE（v1.7.0 起）：MiMo 没有开放任何 API Key
+      // 配额接口（token-plan-* 主机只有 /v1 推理 API，实测见 scripts/probe-mimo.mjs），
+      // 只有 dashboard 账号会话 Cookie 能拿到官方「剩余用量 %」。不填也不影响
+      // —— host 会退回本地用量统计。
       const QUOTA_CRED_REFS = {
         minimax: "MINIMAX_CN_API_KEY",
         deepseek: "DEEPSEEK_API_KEY",
@@ -708,8 +725,14 @@ window.__ModuleLoader__.load({
           return [labelEl, React.createElement("span", { key: "b", style: strong }, txt)];
         }
         if (provider === "mimo") {
-          // MiMo Token Plan：套餐已用% + 本月总额度%（detail 缺失时可能只有一行）
+          // MiMo：官方读数显示「剩余 X%」（balanceText），本地用量显示
+          // 「今日 X · 7d Y」——行内位置窄，只取前半段，完整内容在悬停面板。
           const parts = [labelEl];
+          if (typeof d.balanceText === "string" && d.balanceText) {
+            const compact = d.balanceText.split(" · ")[0];
+            parts.push(React.createElement("span", { key: "bal", style: strong }, compact));
+            return parts;
+          }
           if (typeof d.fiveHrPct === "number") {
             parts.push(React.createElement("span", { key: "plan", style: strong }, "套餐 " + d.fiveHrPct + "%"));
           }
@@ -738,20 +761,24 @@ window.__ModuleLoader__.load({
         if (props.ok && props.display) {
           const d = props.display;
           if (typeof d.balanceText === "string" && d.balanceText) {
+            // mimo 的 balanceText 可能是「本地用量」也可能是官方「剩余 X%」。
+            const cap =
+              props.provider === "mimo"
+                ? (typeof d.weeklyPct === "number" ? "官方剩余用量" : "本地用量（近 7 天 / 今日）")
+                : "账户余额" + (d.currency ? " (" + d.currency + ")" : "");
             rows.push(
               React.createElement(
                 "div", { key: "bal", className: "ts-quota-pop-row" },
-                React.createElement("span", null, "账户余额" + (d.currency ? " (" + d.currency + ")" : "")),
+                React.createElement("span", null, cap),
                 React.createElement("b", null, d.balanceText),
               ),
             );
           }
+          // mimo 官方读数只有一个 Token Plan 窗口（/api/v1/user/usage 的
+          // percent 是「剩余」，host 已换算成已用 %）；本地用量模式没有窗口。
           const windows =
             props.provider === "mimo"
-              ? [
-                  ["套餐已用", d.fiveHrPct, d.fiveHrResetsIn],
-                  ["本月总额度", d.weeklyPct, d.weeklyResetsIn],
-                ]
+              ? [["Token Plan", d.weeklyPct, d.weeklyResetsIn]]
               : [
                   ["5h 窗口", d.fiveHrPct, d.fiveHrResetsIn],
                   ["7d 窗口", d.weeklyPct, d.weeklyResetsIn],
@@ -951,12 +978,17 @@ window.__ModuleLoader__.load({
         }
         const d = v.display || {};
         if (typeof d.balanceText === "string" && d.balanceText) {
+          // mimo 复用 balanceText 承载两种读数：本地用量（无窗口百分比）或
+          // 官方「剩余 X%」（有 weeklyPct），所以标题不能写死「账户余额」。
+          const head = p === "mimo"
+            ? (typeof d.weeklyPct === "number" ? "Token Plan" : "本地用量")
+            : "账户余额" + (d.currency ? " · " + d.currency : "");
           return React.createElement(
             "div", { className: "ts-card ts-quota-card" },
             React.createElement(
               "div", { className: "ts-quota-card-head" },
               React.createElement("span", { className: "ts-quota-card-name" }, label),
-              React.createElement("span", { className: "ts-quota-card-status" }, "账户余额" + (d.currency ? " · " + d.currency : "")),
+              React.createElement("span", { className: "ts-quota-card-status" }, head),
             ),
             React.createElement("div", { className: "ts-quota-card-value" }, d.balanceText),
           );
@@ -1050,7 +1082,14 @@ window.__ModuleLoader__.load({
         const needsCred = names.filter(
           (p) => quotas[p] && quotas[p].ok === false && (quotas[p].kind === "unconfigured" || quotas[p].kind === "auth_failed"),
         );
-        if (configured.length === 0 && needsCred.length === 0) return null;
+        // mimo 零凭据可用（本地用量），所以不会落进 needsCred；这里在它还处于
+        // 本地模式时补一个**可选**的 Cookie 入口——粘了就能升级成官方剩余用量 %。
+        const mimo = quotas.mimo;
+        const mimoLocalMode =
+          !!(mimo && mimo.ok === true) &&
+          typeof mimo.display === "object" &&
+          typeof mimo.display.weeklyPct !== "number";
+        if (configured.length === 0 && needsCred.length === 0 && !mimoLocalMode) return null;
         return React.createElement(
           "div", { className: "ts-block" },
           React.createElement(
@@ -1081,7 +1120,6 @@ window.__ModuleLoader__.load({
                 "div", { className: "ts-cred-block" },
                 React.createElement("div", { className: "ts-block-title" }, "凭据设置（粘贴后保存，自动重新拉取）"),
                 needsCred.map((p) => {
-                  const isAuthFailed = quotas[p] && quotas[p].kind === "auth_failed";
                   return React.createElement(
                     "div", { key: p, className: "ts-cred-row" },
                     React.createElement("span", { className: "ts-cred-label" }, quotaProviderLabel(p)),
@@ -1089,7 +1127,7 @@ window.__ModuleLoader__.load({
                       type: "password",
                       className: "ts-cred-input",
                       placeholder: p === "mimo"
-                        ? (isAuthFailed ? "凭据已失效：重新粘贴 Cookie 或 API Key" : "粘贴登录 Cookie 或 API Key")
+                        ? "粘贴 platform.xiaomimimo.com 的 Cookie 请求头（含 api-platform_serviceToken 与 userId）"
                         : "粘贴 API Key",
                       value: credDrafts[p] || "",
                       onChange: (e) => setCredDrafts((d) => ({ ...d, [p]: e.target.value })),
@@ -1110,6 +1148,38 @@ window.__ModuleLoader__.load({
                 }),
               )
             : null,
+          // mimo 专用：可选的 dashboard Cookie —— 粘了把本地用量升级成官方
+          // 「剩余用量 % + 周重置」；不粘也能正常显示本地用量统计。
+          mimoLocalMode
+            ? React.createElement(
+                "div", { className: "ts-cred-block" },
+                React.createElement("div", { className: "ts-block-title" }, "MiMo 官方剩余用量（可选）"),
+                React.createElement(
+                  "div", { className: "ts-cred-row" },
+                  React.createElement("span", { className: "ts-cred-label" }, "Cookie"),
+                  React.createElement("input", {
+                    type: "password",
+                    className: "ts-cred-input",
+                    placeholder:
+                      "MiMo 未开放 API Key 配额接口；登录 platform.xiaomimimo.com 后从开发者工具复制完整 Cookie 请求头（含 api-platform_serviceToken 与 userId），可显示官方剩余 %（会过期，失效后自动退回本地用量）",
+                    value: credDrafts.mimo || "",
+                    onChange: (e) => setCredDrafts((d) => ({ ...d, mimo: e.target.value })),
+                    onKeyDown: (e) => {
+                      if (e.key === "Enter") saveCred("mimo", credDrafts.mimo || "");
+                    },
+                  }),
+                  React.createElement(
+                    "button", {
+                      className: "ts-cred-save",
+                      disabled: !!credSaving.mimo || !(credDrafts.mimo && credDrafts.mimo.trim()),
+                      onClick: () => saveCred("mimo", credDrafts.mimo || ""),
+                    },
+                    credSaving.mimo ? "保存中…" : "保存",
+                  ),
+                  credMsgs.mimo ? React.createElement("span", { className: "ts-cred-msg" }, credMsgs.mimo) : null,
+                ),
+              )
+            : null,
         );
       }
 

package/index.js

@@ -142,33 +142,61 @@ const QUOTA_PROVIDERS = {
     // 智谱特殊: Authorization 不加 "Bearer " 前缀 (来自 Musage zhipu.rs 注释)
     authStyle: "raw",
   },
-  // Xiaomi MiMo Token Plan — dashboard admin API（非公开 endpoint）：
-  // Bearer 实测 401（session 守护），可靠路径是登录 Cookie；单个凭证值先
-  // Bearer 后 Cookie 自动重试（对齐 Musage xiaomi.rs 的 BearerThenCookie）。
-  // 在 DSH 凭据里把浏览器 DevTools 复制的完整 Cookie 或 API Key 配到
-  // XIAOMI_MIMO_API_KEY / XIAOMI_MIMO_COOKIE（或 MIMO_*）任一 ref；route 派生
-  // 名（设置页按 route 生成的 XIAOMI_TOKEN_PLAN_CN_API_KEY/_COOKIE，与
-  // 其他 provider 的 MINIMAX_CN_* 同规则）同样识别。
-  // Cookie 类 ref 排最前：README 的可靠路径是 Cookie，且 Token 统计页「凭据
-  // 设置」写入 XIAOMI_MIMO_COOKIE——已存在但失效的 API Key（如 route 派生名
-  // 下的 tp- key 被 dashboard 401 拒）不能挡住用户新粘贴 Cookie（v1.5.4）。
+  // Xiaomi MiMo Token Plan — **零凭据可用**（v1.7.0 起重写）。
+  //
+  // 实测（2026-09，scripts/probe-mimo.mjs / probe-mimo-nocookie.mjs）：
+  //  · token-plan-{cn,sgp,ams} 与 api. 主机**只有 OpenAI 兼容的 /v1 推理 API**，
+  //    `/v1/user/balance`、`/api/v1/tokenPlan/usage`、`/api/v1/user/usage` 全部
+  //    404 —— MiMo 没有给 API Key 开任何配额接口。
+  //  · key 与区域强绑定（CN key 在 sgp/ams/api 一律 401 invalid_key），所以也不
+  //    能"换主机重试"。
+  //  · 唯一存在的配额接口是 platform dashboard 的 `/api/v1/user/usage`
+  //    （`{percent, resetDate}`，percent = **剩余**百分比；也是 MiMo 桌面端
+  //    IPC `mimo:getUserUsage` 的同一条链路），但它只认小米账号会话 Cookie。
+  //    拿 tp- key 冒充 serviceToken / X-Service-Token / ?apiKey= 全部 401。
+  //  → v1.6.0 用户看到的 401 正是"把 API Key 打了只认 Cookie 的 dashboard"，
+  //    与 key 是否有效无关。
+  //
+  // 因此不再使用 API Key 读配额（`apiKeyRefs` 已移除）：默认走**本地用量**
+  // （本插件已有的会话日志聚合，零凭据、零过期），配置了 Cookie 时自动升级为
+  // 官方「剩余用量 % + 周重置」，Cookie 失效则静默退回本地读数。
   mimo: {
-    refs: ["XIAOMI_MIMO_COOKIE", "XIAOMI_TOKEN_PLAN_CN_COOKIE", "XIAOMI_MIMO_API_KEY", "XIAOMI_TOKEN_PLAN_CN_API_KEY", "MIMO_COOKIE", "MIMO_API_KEY"],
-    urls: {
-      XIAOMI_TOKEN_PLAN_CN_API_KEY: "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage",
-      XIAOMI_TOKEN_PLAN_CN_COOKIE: "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage",
-      XIAOMI_MIMO_API_KEY: "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage",
-      XIAOMI_MIMO_COOKIE: "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage",
-      MIMO_API_KEY: "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage",
-      MIMO_COOKIE: "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage",
-    },
+    // dashboard 会话 Cookie（唯一能拿到官方套餐 % 的凭据）
+    cookieRefs: ["XIAOMI_MIMO_COOKIE", "XIAOMI_TOKEN_PLAN_CN_COOKIE", "MIMO_COOKIE"],
     parse: parseMimoResponse,
   },
 };
 
-/** Xiaomi MiMo dashboard admin API endpoints（usage + detail，鉴权同一凭证）。 */
-const MIMO_USAGE_URL = "https://platform.xiaomimimo.com/api/v1/tokenPlan/usage";
-const MIMO_DETAIL_URL = "https://platform.xiaomimimo.com/api/v1/tokenPlan/detail";
+/** Xiaomi MiMo 常量 —— 唯一可用的配额接口在 dashboard，且只认账号会话 Cookie。
+ *  协议来源：MiMo 桌面端 IPC `mimo:getUserUsage`（逆向记录见
+ *  https://github.com/ethanweave/mimo-composer-token-status/blob/main/docs/INVESTIGATION.md）、
+ *  CodexBar docs/mimo.md（MIT）、quotas crate mimo.rs（Unlicense）。*/
+const MIMO_PLATFORM = "https://platform.xiaomimimo.com";
+/** 官方桌面端同款：GET {accountBase}/user/usage → { percent(剩余), resetDate }。*/
+const MIMO_USER_USAGE_URL = `${MIMO_PLATFORM}/api/v1/user/usage`;
+/** 旧版套餐明细端点（保留兜底：部分账号只有它给数；已用比例 + 重置时间）。*/
+const MIMO_USAGE_URL = `${MIMO_PLATFORM}/api/v1/tokenPlan/usage`;
+const MIMO_DETAIL_URL = `${MIMO_PLATFORM}/api/v1/tokenPlan/detail`;
+/** dashboard 必需 Cookie 名（CodexBar docs/mimo.md）：缺失就给明确指引。 */
+const MIMO_COOKIE_REQUIRED = ["api-platform_serviceToken", "userId"];
+/** dashboard admin API 需要的额外请求头（quotas crate mimo.rs 用 accept-language: en）。*/
+const MIMO_PLATFORM_HEADERS = { "accept-language": "en" };
+
+/** `"a=1; b=2"` → Map{name: value}（容忍空格、容忍值里有 `=`）。 */
+function cookieStringToMap(s) {
+  const out = new Map();
+  for (const part of String(s || "").split(";")) {
+    const i = part.indexOf("=");
+    if (i <= 0) continue;
+    out.set(part.slice(0, i).trim(), part.slice(i + 1).trim());
+  }
+  return out;
+}
+
+/** Map → `"a=1; b=2"`。 */
+function cookieMapToString(m) {
+  return [...m].map(([k, v]) => k + "=" + v).join("; ");
+}
 
 function quotaBackoffMs(streak) {
   if (streak <= 0) return 0;
@@ -466,7 +494,7 @@ function parseMimoResponse(body, detailBody) {
         ok: false,
         provider: "mimo",
         kind: "auth_failed",
-        message: "MiMo 凭据已失效（Cookie 过期或未登录），请到 platform.xiaomimimo.com 重新复制",
+        message: "MiMo 凭据已失效（API Key 或 Cookie 过期），请到 platform.xiaomimimo.com 续费或重新生成",
       };
     }
     return {
@@ -549,6 +577,86 @@ function parseMimoResponse(body, detailBody) {
   };
 }
 
+// ----- xiaomi mimo /api/v1/user/usage parser (v1.7.0，官方桌面端同款链路) -----
+//   { "percent": 78, "resetDate": "2026-09-16" }
+// **percent 是「剩余」百分比**（账户菜单「剩余用量 78%」），与上面
+// tokenPlan/usage 的 items[].percent（**已用**比例）语义相反，别混用。
+// wire 里 fiveHrPct/weeklyPct 一律是「已用 %」，所以取 100 - percent。
+
+function parseMimoUserUsage(body) {
+  let json;
+  try {
+    json = typeof body === "string" ? JSON.parse(body) : body;
+  } catch {
+    return { ok: false, provider: "mimo", kind: "parse", message: "MiMo 响应 JSON 解析失败" };
+  }
+  if (!json || typeof json !== "object") {
+    return { ok: false, provider: "mimo", kind: "parse", message: "MiMo 响应不是对象" };
+  }
+  if (typeof json.code === "number" && json.code !== 0) {
+    if (json.code === 401 || (json.code >= 40100 && json.code < 40200)) {
+      return {
+        ok: false,
+        provider: "mimo",
+        kind: "auth_failed",
+        message: "MiMo Cookie 已失效，请重新登录 platform.xiaomimimo.com 并复制 Cookie 请求头",
+      };
+    }
+    return {
+      ok: false,
+      provider: "mimo",
+      kind: "server_error",
+      message: "MiMo 业务错误 code=" + json.code + " · " + (json.message || ""),
+    };
+  }
+  const data = json.data && typeof json.data === "object" ? json.data : json;
+
+  const raw = Number(data.percent);
+  if (!isFinite(raw)) {
+    return {
+      ok: false,
+      provider: "mimo",
+      kind: "parse",
+      message: "MiMo 响应缺少 percent 字段（keys: " + Object.keys(data).join(",") + "）",
+    };
+  }
+  const remaining = Math.max(0, Math.min(100, Math.round(raw)));
+  const used = 100 - remaining;
+
+  // resetDate 形如 "2026-09-16"（本地日），按当天 23:59:59 解释为到期时刻。
+  let resetsAt = null;
+  if (typeof data.resetDate === "string" && data.resetDate) {
+    const iso = data.resetDate.length <= 10 ? data.resetDate + "T23:59:59" : data.resetDate;
+    const t = Date.parse(iso);
+    if (!isNaN(t)) resetsAt = t;
+  }
+  const resetsIn = resetsAt ? formatResetsIn(resetsAt) : null;
+
+  return {
+    ok: true,
+    provider: "mimo",
+    display: {
+      // 剩余用量是单一窗口（账户菜单标「1 周」），映射到 7d 窗口位
+      weeklyPct: used,
+      weeklyResetsIn: resetsIn,
+      fiveHrPct: null,
+      fiveHrResetsIn: null,
+      balanceText: "剩余 " + remaining + "%",
+      balanceUsd: null,
+      currency: null,
+    },
+  };
+}
+
+/** 12345678 → "12.3M"（读数行/卡片用的紧凑 token 计数）。 */
+function formatTokenCount(n) {
+  if (!isFinite(n) || n <= 0) return "0";
+  if (n >= 1e9) return (n / 1e9).toFixed(n >= 1e10 ? 0 : 1) + "B";
+  if (n >= 1e6) return (n / 1e6).toFixed(n >= 1e7 ? 0 : 1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(n >= 1e4 ? 0 : 1) + "K";
+  return String(Math.round(n));
+}
+
 function formatResetsIn(resetsAtMs) {
   if (typeof resetsAtMs !== "number" || !resetsAtMs) return "";
   const ms = resetsAtMs - Date.now();
@@ -1035,30 +1143,63 @@ export class TokenStatsService extends TypertRemoteService {
    * each provider's shipped default `apiKeyEnv`; without the credentials
    * service (headless deployment) the process environment is consulted.
    */
+  /**
+   * Resolve credentials for one provider through the DSH credentials seam.
+   * Ref candidates follow the settings page's `<ROUTE>_API_KEY` derivation and
+   * each provider's shipped default `apiKeyEnv`; without the credentials
+   * service (headless deployment) the process environment is consulted.
+   *
+   * v1.6.0 起，mimo 同时持有 API Key (Bearer) + Cookie (dashboard session) 两类
+   * 凭据；其他 provider 只用 API Key。返回值总是
+   *   { apiKey, apiKeyRef, cookie, cookieRef }，
+   * 未配置那一路为 null。`_quotaActiveRef[provider + ":api" | ":cookie"]` 按
+   * provider+kind 缓存上次命中的 ref（保持粘性，但不互锁）。
+   */
   async _quotaApiKey(provider) {
     const cfg = QUOTA_PROVIDERS[provider];
-    if (!cfg) return { ref: null, key: null };
+    if (!cfg) return { apiKey: null, apiKeyRef: null, cookie: null, cookieRef: null };
     const credentials = this.ctx.get("credentials");
-    const candidates = this._quotaActiveRef[provider]
-      ? [this._quotaActiveRef[provider], ...cfg.refs.filter((r) => r !== this._quotaActiveRef[provider])]
-      : cfg.refs;
-    for (const ref of candidates) {
+    // 兼容新旧两种配置形态：新的是 {apiKeyRefs, cookieRefs}，旧的是单数组 refs。
+    const apiKeyRefList = cfg.apiKeyRefs || cfg.refs || [];
+    const cookieRefList = cfg.cookieRefs || [];
+
+    const resolveOne = async (ref) => {
       try {
         if (credentials && typeof credentials.resolve === "function") {
           const hit = await credentials.resolve(ref);
-          if (hit && hit.value) {
-            this._quotaActiveRef[provider] = ref;
-            return { ref, key: hit.value };
-          }
+          if (hit && hit.value) return hit.value;
         } else if (typeof process !== "undefined" && process.env && process.env[ref]) {
-          this._quotaActiveRef[provider] = ref;
-          return { ref, key: process.env[ref] };
+          return process.env[ref];
         }
       } catch (e) {
         /* try the next ref */
       }
-    }
-    return { ref: null, key: null };
+      return null;
+    };
+
+    const resolveList = async (refList, activeKey) => {
+      const active = this._quotaActiveRef[activeKey];
+      const candidates = active
+        ? [active, ...refList.filter((r) => r !== active)]
+        : refList;
+      for (const ref of candidates) {
+        const v = await resolveOne(ref);
+        if (v) {
+          this._quotaActiveRef[activeKey] = ref;
+          return { ref, value: v };
+        }
+      }
+      return { ref: null, value: null };
+    };
+
+    const api = await resolveList(apiKeyRefList, provider + ":api");
+    const ck = await resolveList(cookieRefList, provider + ":cookie");
+    return {
+      apiKey: api.value,
+      apiKeyRef: api.ref,
+      cookie: ck.value,
+      cookieRef: ck.ref,
+    };
   }
 
   async _resolveCurl() {
@@ -1072,7 +1213,7 @@ export class TokenStatsService extends TypertRemoteService {
   }
 
   /** curl fallback for hosts without a global fetch (same shape as musage). */
-  async _curlGet(url, key, authStyle) {
+  async _curlGet(url, key, authStyle, extraHeaders) {
     const subprocess = this.ctx.get("subprocess");
     if (!subprocess || typeof subprocess.spawn !== "function") {
       return { ok: false, kind: "network", message: "subprocess service 不可用, 且宿主无全局 fetch" };
@@ -1084,15 +1225,19 @@ export class TokenStatsService extends TypertRemoteService {
         : authStyle === "cookie"
           ? "Cookie: " + key
           : "Authorization: Bearer " + key;
+    const argv = [
+      c, "-sS",
+      "--max-time", String(Math.floor(QUOTA_REQUEST_TIMEOUT_MS / 1000)),
+      "-w", "\n%{http_code}",
+      "-H", authHeader,
+      "-H", "Accept: application/json",
+    ];
+    for (const [name, value] of Object.entries(extraHeaders || {})) {
+      argv.push("-H", name + ": " + value);
+    }
+    argv.push(url);
     const handle = subprocess.spawn({
-      argv: [
-        c, "-sS",
-        "--max-time", String(Math.floor(QUOTA_REQUEST_TIMEOUT_MS / 1000)),
-        "-w", "\n%{http_code}",
-        "-H", authHeader,
-        "-H", "Accept: application/json",
-        url,
-      ],
+      argv,
       cwd: "/",
       stdio: {
         stdin: "ignore",
@@ -1126,11 +1271,13 @@ export class TokenStatsService extends TypertRemoteService {
     return { ok: true, body };
   }
 
-  /** GET one provider endpoint with its API key; fetch first, curl fallback. */
-  async _httpGet(url, key, authStyle) {
+  /** GET one provider endpoint with its API key; fetch first, curl fallback.
+   *  `extraHeaders` carries provider-specific headers (e.g. MiMo dashboard 的
+   *  accept-language: en)，fetch 与 curl 两条路径都要带上。 */
+  async _httpGet(url, key, authStyle, extraHeaders) {
     if (typeof fetch === "function") {
       try {
-        const headers = { accept: "application/json" };
+        const headers = { accept: "application/json", ...(extraHeaders || {}) };
         // authStyle: undefined → Bearer； "raw" → 原样 Authorization（智谱）；
         // "cookie" → 整串 Cookie 头（小米 MiMo dashboard admin API）。
         if (authStyle === "cookie") headers.cookie = key;
@@ -1141,20 +1288,25 @@ export class TokenStatsService extends TypertRemoteService {
           signal: AbortSignal.timeout(QUOTA_REQUEST_TIMEOUT_MS),
         });
         const body = await res.text();
+        // 带回 Set-Cookie：mimo 的 cookie jar 靠它接住服务端续发的会话
+        // （浏览器自动存，我们此前每次重发死 cookie，等于放弃了续期）。
+        const setCookie = typeof res.headers.getSetCookie === "function" ? res.headers.getSetCookie() : [];
         if (res.status !== 200) {
           return {
             ok: false,
             kind: classifyQuotaHttpStatus(res.status),
             httpStatus: res.status,
+            setCookie,
             message: "HTTP " + res.status + " · " + body.slice(0, 200),
           };
         }
-        return { ok: true, body };
+        return { ok: true, body, setCookie };
       } catch (e) {
         return { ok: false, kind: "network", message: "fetch 失败: " + String((e && e.message) || e) };
       }
     }
-    return this._curlGet(url, key, authStyle);
+    // curl 回退路径不带 Set-Cookie（无法维持会话续期，仅影响 mimo 的 cookie 升级）。
+    return this._curlGet(url, key, authStyle, extraHeaders);
   }
 
   async _fetchProviderQuota(provider) {
@@ -1162,8 +1314,9 @@ export class TokenStatsService extends TypertRemoteService {
     if (!cfg) {
       return { ok: false, provider, kind: "other", message: "未知 provider: " + provider };
     }
-    const { ref, key } = await this._quotaApiKey(provider);
-    if (!key) {
+    const { apiKey, apiKeyRef, cookie, cookieRef } = await this._quotaApiKey(provider);
+    if (provider === "mimo") return this._fetchMimoQuota(apiKey, apiKeyRef, cookie, cookieRef);
+    if (!apiKey) {
       return {
         ok: false,
         provider,
@@ -1171,29 +1324,184 @@ export class TokenStatsService extends TypertRemoteService {
         message: "未配置 " + provider + " API Key (在 DSH 模型设置里配置对应 provider)",
       };
     }
-    if (provider === "mimo") return this._fetchMimoQuota(key);
-    const url = cfg.urls[ref] || cfg.urls[cfg.refs[0]];
-    const raw = await this._httpGet(url, key, cfg.authStyle);
+    const refList = cfg.apiKeyRefs || cfg.refs || [];
+    const url = cfg.urls[apiKeyRef] || cfg.urls[refList[0]];
+    const raw = await this._httpGet(url, apiKey, cfg.authStyle);
     if (!raw.ok) return { ...raw, provider };
     return cfg.parse(raw.body);
   }
 
   /**
-   * Xiaomi MiMo Token Plan（dashboard admin API，契约来自 Musage xiaomi.rs）：
-   * 同一凭证值先按 Bearer 试，401/403 时原样改 `Cookie:` 头重试；usage 成功
-   * 后再 best-effort 拉一次 detail（周期结束时间 / 过期标记）。detail 失败
-   * 不影响 usage 结果（只是没有重置倒计时）。
+   * MiMo 本地用量（零凭据、零过期）：从会话日志聚合里筛出 MiMo 模型，
+   * 算「今日 / 近 7 天（含今天）」消耗 token。provider 判定与 client 的
+   * PROVIDER_ALIASES 同一套包含回退（route id 用户自由命名）。
+   */
+  _mimoLocalUsage() {
+    const isMimo = (meta, key) => {
+      const p = String((meta && meta.provider) || "").toLowerCase();
+      if (p) return p.includes("mimo") || p.includes("xiaomi");
+      const n = String((meta && meta.name) || key || "").toLowerCase();
+      return n.includes("mimo");
+    };
+    const now = Date.now();
+    const todayKey = this._dayKeyOf(now);
+    const weekCut = this._dayKeyOf(now - 6 * DAY_MS);
+    let today = 0;
+    let week = 0;
+    for (const [dk, day] of this._byDay) {
+      if (dk > todayKey) continue;
+      let dayTotal = 0;
+      for (const [key, rec] of day) {
+        const meta = this._modelMeta.get(key);
+        if (!isMimo(meta, key)) continue;
+        dayTotal += rec.total || 0;
+      }
+      if (dk === todayKey) today = dayTotal;
+      if (dk >= weekCut) week += dayTotal;
+    }
+    return { today, week };
+  }
+
+  /**
+   * 最小 cookie jar：把响应 `Set-Cookie` 里属于 MiMo 的条目吸收进当前 cookie 串，
+   * 并写回 DSH 凭据库，使服务端续发的会话能跨轮询、跨重启生效。
+   *
+   * 只吸收两类名字：jar 里已存在的（续期/轮换同一条 cookie），以及 MiMo 已知的那几个
+   * （防止服务端塞进无关 cookie 污染用户粘贴的内容）。没有变化则不写盘。
+   *
+   * @returns {Promise<string|null>} 合并后的新 cookie 串；无变化返回 null。
    */
-  async _fetchMimoQuota(key) {
-    let raw = await this._httpGet(MIMO_USAGE_URL, key, undefined);
-    let cookie = false;
-    if (!raw.ok && (raw.httpStatus === 401 || raw.httpStatus === 403)) {
-      raw = await this._httpGet(MIMO_USAGE_URL, key, "cookie");
-      cookie = true;
+  async _absorbMimoCookie(cookieRef, current, setCookieHeaders) {
+    if (!Array.isArray(setCookieHeaders) || setCookieHeaders.length === 0) return null;
+    const jar = cookieStringToMap(current);
+    const known = new Set([...MIMO_COOKIE_REQUIRED, "api-platform_ph", "api-platform_slh"]);
+    let changed = false;
+    for (const raw of setCookieHeaders) {
+      // 只取第一段 `name=value`，后面的 Path/HttpOnly/Expires 是属性不是 cookie
+      const pair = String(raw).split(";")[0];
+      const i = pair.indexOf("=");
+      if (i <= 0) continue;
+      const name = pair.slice(0, i).trim();
+      if (!name) continue;
+      if (!jar.has(name) && !known.has(name)) continue;
+      const value = pair.slice(i + 1).trim();
+      // 浏览器语义：空值或 Max-Age=0 表示**删除**该 cookie，不是把它置空
+      // （置空会发出 `api-platform_serviceToken=`，等于带着坏 cookie 去请求）。
+      if (value === "" || /;\s*max-age\s*=\s*0/i.test(raw)) {
+        if (jar.delete(name)) changed = true;
+        continue;
+      }
+      if (jar.get(name) === value) continue;
+      jar.set(name, value);
+      changed = true;
     }
-    if (!raw.ok) return { ...raw, provider: "mimo" };
-    const detail = await this._httpGet(MIMO_DETAIL_URL, key, cookie ? "cookie" : undefined);
-    return parseMimoResponse(raw.body, detail && detail.ok ? detail.body : null);
+    if (!changed) return null;
+    const next = cookieMapToString(jar);
+    const credentials = this.ctx.get("credentials");
+    // 服务端把会话 cookie 全清掉了 = 会话没了：删掉凭据比留个空串更贴近浏览器，
+    // 下一轮会自然退回本地用量，而不是带着空 cookie 反复 401。
+    if (!next) {
+      try {
+        if (cookieRef && credentials && typeof credentials.unset === "function") {
+          await credentials.unset(cookieRef);
+        }
+      } catch {
+        /* 写回失败不影响本次读数 */
+      }
+      return null;
+    }
+    // 写回官方凭据库（宿主侧 credentials.set）；失败只影响跨重启续期，本进程内
+    // 仍用 next 继续请求，所以吞掉异常。
+    try {
+      if (cookieRef && credentials && typeof credentials.set === "function") {
+        await credentials.set(cookieRef, next);
+      }
+    } catch {
+      /* 写回失败不影响本次读数 */
+    }
+    return next;
+  }
+
+  /** MiMo 读数（v1.7.0）：官方 Cookie 优先，失败静默退回本地用量。 */
+  async _fetchMimoQuota(_apiKey, _apiKeyRef, cookie, cookieRef) {
+    if (cookie) {
+      const official = await this._fetchMimoOfficial(cookie, cookieRef);
+      if (official.ok) return official;
+      // Cookie 失效（auth_failed）→ 不打扰用户，静默退回本地用量。
+      // 其余（套餐过期 / 解析失败 / 限流 / 5xx）都是真实状态，如实上报。
+      if (official.kind !== "auth_failed") return official;
+    }
+    const local = this._mimoLocalUsage();
+    return {
+      ok: true,
+      provider: "mimo",
+      display: {
+        fiveHrPct: null,
+        weeklyPct: null,
+        fiveHrResetsIn: null,
+        weeklyResetsIn: null,
+        balanceText: "今日 " + formatTokenCount(local.today) + " · 7d " + formatTokenCount(local.week),
+        balanceUsd: null,
+        currency: null,
+      },
+    };
+  }
+
+  /**
+   * 官方 dashboard 配额（仅 Cookie）：主用桌面端同款 `/api/v1/user/usage`
+   * （percent=剩余 + resetDate），失败再退到旧版 `/api/v1/tokenPlan/usage`
+   * + `/detail`（已用比例）。两条都不通 = Cookie 失效。
+   */
+  async _fetchMimoOfficial(cookie, cookieRef) {
+    const missing = MIMO_COOKIE_REQUIRED.filter((n) => cookie.indexOf(n) < 0);
+    if (missing.length === MIMO_COOKIE_REQUIRED.length) {
+      return {
+        ok: false,
+        provider: "mimo",
+        kind: "auth_failed",
+        message:
+          "MiMo Cookie 缺少 " + MIMO_COOKIE_REQUIRED.join(" / ") +
+          "：登录 platform.xiaomimimo.com 后从开发者工具复制完整 Cookie 请求头",
+      };
+    }
+
+    // 每个响应后立刻吸收 Set-Cookie：服务端续发的会话要马上用于后续请求
+    // （browser jar 的等价行为），否则同一轮里还在用旧 token。
+    const jar = async (res) => {
+      const next = await this._absorbMimoCookie(cookieRef, cookie, res && res.setCookie);
+      if (next) cookie = next;
+      return res;
+    };
+
+    const user = await jar(await this._httpGet(MIMO_USER_USAGE_URL, cookie, "cookie", MIMO_PLATFORM_HEADERS));
+    if (user.ok) {
+      const parsed = parseMimoUserUsage(user.body);
+      if (parsed.ok) return parsed;
+      // 业务码 401 = 会话已死，不用再试旧端点。
+      if (parsed.kind === "auth_failed") return parsed;
+    } else if (user.httpStatus === 401 || user.httpStatus === 403) {
+      return { ...user, provider: "mimo" };
+    } else if (user.kind === "rate_limited" || (user.httpStatus >= 500 && user.httpStatus < 600)) {
+      return { ...user, provider: "mimo" };
+    }
+    // 404（该账号没有这个端点）或其它 → 退到旧版 tokenPlan/usage + detail。
+    // detail 必须先拉（expired 标记 + 重置时间要在 usage 解析前拿到）。
+    const detail = await jar(await this._httpGet(MIMO_DETAIL_URL, cookie, "cookie", MIMO_PLATFORM_HEADERS));
+    const usage = await jar(await this._httpGet(MIMO_USAGE_URL, cookie, "cookie", MIMO_PLATFORM_HEADERS));
+    if (usage.ok) {
+      const parsed = parseMimoResponse(usage.body, detail.ok ? detail.body : null);
+      // plan_expired / schema_unknown / parse 都是"拿到了但内容不对"，如实上报；
+      // 只有 auth_failed 才继续降级。
+      if (parsed.ok || parsed.kind !== "auth_failed") return parsed;
+    }
+    return {
+      ok: false,
+      provider: "mimo",
+      kind: "auth_failed",
+      message:
+        "MiMo Cookie 已失效（" + MIMO_USER_USAGE_URL.replace("https://", "") +
+        " 返回 " + (user.httpStatus || "异常") + "）：重新登录 platform.xiaomimimo.com 后复制 Cookie",
+    };
   }
 
   /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@duke-dsh-plugins/dsh-token-stats",
-  "version": "1.5.5",
-  "description": "Token usage statistics for DeepSeek Harness (7/30-day per-model charts + yearly heatmap) plus an inline coding-plan balance/quota readout in the composer (minimax/deepseek/kimi/openrouter/zhipu).",
+  "version": "1.7.0",
+  "description": "Token usage statistics for DeepSeek Harness (7/30-day per-model charts + yearly heatmap) plus an inline coding-plan balance/quota readout in the composer (minimax/deepseek/kimi/openrouter/zhipu/mimo; mimo falls back to local usage since MiMo exposes no API-key quota API).",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MoonlitDropOfBlood/dsh-token-stats.git"
@@ -27,7 +27,7 @@
   ],
   "license": "MIT",
   "engines": {
-    "dsh": ">=0.1.4-rc.2 <0.2.0"
+    "dsh": ">=0.1.4-rc.2 <0.3.0"
   },
   "dsh": {
     "bundle": {
@@ -39,8 +39,8 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh": ">=0.1.4-rc.2 <0.2.0",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.7"
+    "@deepseek-ai/dsh": ">=0.1.4-rc.2 <0.3.0",
+    "@deepseek-ai/dsh-typert-protocol": "^0.1.0-rc.7 || ^0.2.0-rc.1"
   },
   "dependencies": {
     "zod": "^4.4.3"
@@ -50,6 +50,11 @@
     "smoke": "node scripts/smoke-store.mjs",
     "smoke:quota": "node scripts/smoke-quota.mjs",
     "smoke:robust": "node scripts/smoke-robust-host.mjs && node scripts/smoke-robust-client.mjs",
-    "smoke:typert": "node scripts/smoke-typert.mjs"
+    "smoke:typert": "node scripts/smoke-typert.mjs",
+    "smoke:compat": "node scripts/smoke-compat.mjs",
+    "probe:mimo": "node scripts/probe-mimo.mjs",
+    "probe:mimo:nocookie": "node scripts/probe-mimo-nocookie.mjs",
+    "probe:mimo:session": "node scripts/probe-mimo-session.mjs",
+    "e2e": "npm run check && npm run smoke && npm run smoke:quota && npm run smoke:robust && npm run smoke:typert && npm run smoke:compat && node scripts/repro-client-mount.mjs && node scripts/repro-strict-dispatch.mjs && node scripts/repro-profile-boot.mjs"
   }
 }