balance-dsh 1.2.2 → 1.3.0

package/lib/index.js

@@ -175,14 +175,15 @@ function modelKey(model) {
   return "";
 }
 
-/** 解析价格：模型基价 + config.price 覆盖，config.peak: true 时按高峰价翻倍。
- *  era = "legacy" 时取调价前的历史价（目前仅 flash 系列与现价不同）。 */
-function resolvePricing(config, model = "", era = "current") {
+/** 目录价（**不含峰谷倍率**）：模型基价 + 覆盖价（`config.priceByModel[模型]` 优先，其次 `config.price`）。
+ *  era = "legacy" 时取调价前的历史价（目前仅 flash 系列与现价不同）。
+ *  注意：用户在配置界面填了覆盖价时，该价对所有计费时代生效（他是主动要改价，不是历史重算）。
+ *  ⚠️ 精确计费（estimateCost）必须用这个**原价**，否则会与高峰倍率重复相乘（见 estimateCost 注释）。 */
+function catalogPricing(config, model = "", era = "current") {
   const key = modelKey(model);
   const base = (era === "legacy" && LEGACY_MODEL_PRICING[key]) || MODEL_PRICING[key] || FALLBACK_PRICING;
-  const price = config?.price ?? {};
-  const multiplier = config?.peak === true ? 2 : 1;
-  const pick = (name, fallback) => Number(price[name] ?? fallback) * multiplier;
+  const price = config?.priceByModel?.[key] ?? config?.price ?? {};
+  const pick = (name, fallback) => Number(price[name] ?? fallback);
   return {
     inputCnyPerMillion: pick("inputCnyPerMillion", base.inputCnyPerMillion),
     cacheReadCnyPerMillion: pick("cacheReadCnyPerMillion", base.cacheReadCnyPerMillion),
@@ -191,6 +192,26 @@ function resolvePricing(config, model = "", era = "current") {
   };
 }
 
+/** 高峰时段价格倍率：`config.peakMultiplier`（旧的 `config.peak: true` 等价于 ×2）。 */
+function peakMultiplierOf(config) {
+  const custom = Number(config?.peakMultiplier);
+  if (Number.isFinite(custom) && custom > 0) return custom;
+  return config?.peak === true ? 2 : 1;
+}
+
+/** 当前时段价 = 目录价 × 高峰倍率。**仅用于展示**（客户端按它估算"此刻"的单价）；
+ *  精确计费请用 `catalogPricing` + `peakMultiplierOf` 组合，不要用这个函数的结果再乘倍率。 */
+function resolvePricing(config, model = "", era = "current") {
+  const base = catalogPricing(config, model, era);
+  const multiplier = peakMultiplierOf(config);
+  return {
+    inputCnyPerMillion: base.inputCnyPerMillion * multiplier,
+    cacheReadCnyPerMillion: base.cacheReadCnyPerMillion * multiplier,
+    cacheWriteCnyPerMillion: base.cacheWriteCnyPerMillion * multiplier,
+    outputCnyPerMillion: base.outputCnyPerMillion * multiplier,
+  };
+}
+
 /** 取会话事件数组。DSH 2.0.4 起 live session **不再有 `.events` 属性**，改用 `snapshotEvents()` 方法
  *  （签名 `snapshotEvents(fromSeq = 0, toSeqExclusive = seq)`，可无参调用取全部事件）；
  *  旧版仍读 `.events` 属性。两者都拿不到时返回空数组（由调用方降级）。 */
@@ -322,7 +343,7 @@ function formatBalance(balance) {
 //                          | { status:"failed" }  （网络失败；官方明确“失败绝不变成 0 余额”）
 // client 是 AccountClientMetadata（version / locale / timezoneOffsetSeconds），
 // 缺字段会在平台侧组装请求头时抛错，所以三个字段都要给。
-const PLUGIN_VERSION = "1.2.2";
+const PLUGIN_VERSION = "1.3.0";
 
 /**
  * 读取官方账号余额并归一化成与 normalizeBalance 相同的形状。
@@ -371,8 +392,7 @@ function normalizeAccountBalance(result) {
 }
 
 /** 取余额：官方账号优先，回退 DeepSeek API Key。返回 { balance, error }，二者必有其一。 */
-async function resolveBalance(ctx, config, signal) {
-  const fromAccount = await fetchAccountBalance(ctx);
+async function resolveBalance(ctx, config, signal) {  const fromAccount = await fetchAccountBalance(ctx);
   if (fromAccount !== null) return { balance: fromAccount, error: null };
   const apiKey = await resolveApiKey(ctx, config);
   if (apiKey === "") {
@@ -404,6 +424,25 @@ function collectModelSwitches(events) {
   return switches;
 }
 
+/** 建立 `turn/step` → **请求发起时刻** 的映射（取自 step/start 事件）。
+ *  峰谷判定、模型归属、价格时代都应该看"发起时刻"，而不是 assistant/message 的完成时刻：
+ *  请求跨越时段边界时（如 11:59 发起、12:01 完成），按发起时刻归属才符合"按请求到达时刻计费"。
+ *  实测平均请求耗时 5.6 秒、最长 127 秒，撞上边界的概率极低，但这样更严谨。
+ *  拿不到 step/start（旧数据、部分子代理会话）时由调用方回退到完成时刻。 */
+function stepStartTimes(events) {
+  const starts = new Map();
+  for (const event of events ?? []) {
+    if (event.type !== "step/start") continue;
+    const turn = event.data?.turn;
+    const step = event.data?.step;
+    if (turn === void 0 || step === void 0) continue;
+    const time = Number(event.time);
+    if (!Number.isFinite(time)) continue;
+    starts.set(`${turn}/${step}`, time);
+  }
+  return starts;
+}
+
 /** 找到 time 之前最近一次模型切换点的模型；无切换点（或早于第一个）返回 ""（调用方回退到后备模型）。 */
 function modelAtTime(switches, time) {
   let model = "";
@@ -418,6 +457,7 @@ function modelAtTime(switches, time) {
  *  供 live 会话与持久化（子代理）会话复用。返回按模型拆分的 byModel，及跨模型聚合字段。 */
 function sumEventsUsage(events, config, fallbackModel = "") {
   const switches = collectModelSwitches(events);
+  const starts = stepStartTimes(events);
   const fallback = fallbackModel !== "" ? fallbackModel : "deepseek-v4-flash";
   const latestByStep = new Map();
   for (const event of events ?? []) {
@@ -427,7 +467,9 @@ function sumEventsUsage(events, config, fallbackModel = "") {
     const turn = event.data?.turn;
     const step = event.data?.step;
     if (turn === void 0 || step === void 0) continue;
-    latestByStep.set(`${turn}/${step}`, { usage, time: event.time ?? Date.now() });
+    // 时刻取"请求发起时刻"（step/start），拿不到时回退 assistant/message 的完成时刻
+    const time = starts.get(`${turn}/${step}`) ?? event.time ?? Date.now();
+    latestByStep.set(`${turn}/${step}`, { usage, time });
   }
   const add = (bucket, usage) => {
     bucket.inputTokens += usage.inputTokens ?? 0;
@@ -451,7 +493,7 @@ function sumEventsUsage(events, config, fallbackModel = "") {
   const offpeak = empty();
   const modelList = [];
   for (const e of byModel.values()) {
-    modelList.push({ model: e.model, era: e.era, peak: e.peak, offpeak: e.offpeak, cost: estimateCost(e, resolvePricing(config, e.model, e.era)) });
+    modelList.push({ model: e.model, era: e.era, peak: e.peak, offpeak: e.offpeak, cost: estimateCost(e, catalogPricing(config, e.model, e.era), peakMultiplierOf(config)) });
     peak.inputTokens += e.peak.inputTokens;
     peak.outputTokens += e.peak.outputTokens;
     peak.cacheReadTokens += e.peak.cacheReadTokens;
@@ -485,22 +527,188 @@ function sumSessionUsage(session, config) {
   return sumEventsUsage(sessionEvents(session), config, detectModel(session));
 }
 
-function estimateCost(usage, pricing) {
-  const costOf = (u) =>
-    (u.inputTokens * pricing.inputCnyPerMillion +
+/** 精确计费：高峰桶按**目录价 × 倍率**、空闲桶按目录价。
+ *  ⚠️ `pricing` 必须是 `catalogPricing()` 的**原价**（不含倍率）。历史上这里收的是
+ *  `resolvePricing()` 的结果（已含倍率），再乘一次 2 导致高峰 ×4、空闲 ×2 —— 金额虚高约 3 倍。 */
+function estimateCost(usage, pricing, multiplier = 2) {
+  const costOf = (u, factor) =>
+    ((u.inputTokens * pricing.inputCnyPerMillion +
       u.cacheReadTokens * pricing.cacheReadCnyPerMillion +
       u.cacheWriteTokens * pricing.cacheWriteCnyPerMillion) /
       1_000_000 +
-    (u.outputTokens * pricing.outputCnyPerMillion) / 1_000_000;
-  // 跨时段精确计费：高峰桶按高峰价（= 目录价 × 2）、空闲桶按目录价。
-  // 注意：若 config.peak:true（resolvePricing 已统一翻倍），高峰桶会再乘一次，两种方式不要同时用。
-  return costOf(usage.peak) * 2 + costOf(usage.offpeak);
+      (u.outputTokens * pricing.outputCnyPerMillion) / 1_000_000) *
+    factor;
+  return costOf(usage.peak, multiplier) + costOf(usage.offpeak, 1);
 }
 
 const STATS_DAYS = 90;
 const STATS_MAX_SESSIONS = 200;
 const STATS_CACHE_MS = 5 * 60 * 1000;
 
+// ───────────────────────────────────────────────────────────────────────────
+// 插件设置：由 DSH「插件」页 → balance-dsh 详情页的配置卡片读写（slot
+// `plugins.bundle.config`，见 lib/client.js），落在 <dshHome>/balance-dsh.json。
+// 刻意不接 DSH 的 settings / storageDomain 服务——那些内部 API 无兼容承诺，
+// 而这个插件已经被 DSH 升级打断过多次；普通 JSON 文件不会因升级失效。
+// ───────────────────────────────────────────────────────────────────────────
+
+const SETTINGS_FILENAME = "balance-dsh.json";
+
+/** 出厂默认值；同时是字段白名单（不在这里的键一律丢弃）。 */
+const DEFAULT_SETTINGS = {
+  // 余额
+  refreshIntervalSec: 60, // 余额轮询间隔（秒）
+  lowBalanceThreshold: 10, // 低于该金额用警示色
+  apiKey: "", // 官方账号未登录时的回退凭据
+  // 显示
+  showBalanceRow: true, // 展开态侧栏底部的余额行
+  showUsagePill: true, // 输入框下方「本会话消耗」胶囊
+  showPeriodLabel: true, // 高峰/空闲标签
+  showFab: true, // 收起态悬浮圆钮
+  // 收起态圆钮外观
+  fabSize: 60, // 直径（px）
+  fabLeft: 44, // 距窗口左缘（px）
+  // 统计
+  statsSessionLimit: STATS_MAX_SESSIONS, // 统计扫描的最近会话数
+  statsCacheSec: 300, // 统计结果缓存秒数
+  // 计费
+  peakMultiplier: 2, // 高峰时段倍率
+  priceFlash: null, // flash 覆盖价（元/百万 token），四项全填才生效
+  pricePro: null, // v4-pro 覆盖价
+};
+
+const PRICE_FIELDS = [
+  "inputCnyPerMillion",
+  "cacheReadCnyPerMillion",
+  "cacheWriteCnyPerMillion",
+  "outputCnyPerMillion",
+];
+
+/** 夹到合法区间；非有限数回退默认值。 */
+function clampNumber(value, min, max, fallback) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(max, Math.max(min, n));
+}
+
+/** 一组覆盖价：逐个字段校验（有限非负数才收），不填的字段留空表示「用默认价」。
+ *  四个字段都没填则整组丢弃（等价于不覆盖）。 */
+function normalizePriceOverride(raw) {
+  if (raw == null || typeof raw !== "object") return null;
+  const out = {};
+  for (const field of PRICE_FIELDS) {
+    const input = raw[field];
+    if (input == null || input === "") continue;
+    const n = Number(input);
+    if (!Number.isFinite(n) || n < 0) continue;
+    out[field] = n;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
+/** 校验并补全一份设置：未知键丢弃、越界值夹紧、类型不符回退默认。 */
+function normalizeSettings(raw) {
+  const src = raw != null && typeof raw === "object" ? raw : {};
+  const d = DEFAULT_SETTINGS;
+  const bool = (value, fallback) => (typeof value === "boolean" ? value : fallback);
+  return {
+    refreshIntervalSec: clampNumber(src.refreshIntervalSec, 5, 3600, d.refreshIntervalSec),
+    lowBalanceThreshold: clampNumber(src.lowBalanceThreshold, 0, 100000, d.lowBalanceThreshold),
+    apiKey: typeof src.apiKey === "string" ? src.apiKey.trim() : d.apiKey,
+    showBalanceRow: bool(src.showBalanceRow, d.showBalanceRow),
+    showUsagePill: bool(src.showUsagePill, d.showUsagePill),
+    showPeriodLabel: bool(src.showPeriodLabel, d.showPeriodLabel),
+    showFab: bool(src.showFab, d.showFab),
+    fabSize: clampNumber(src.fabSize, 32, 120, d.fabSize),
+    fabLeft: clampNumber(src.fabLeft, 0, 600, d.fabLeft),
+    statsSessionLimit: clampNumber(src.statsSessionLimit, 10, 2000, d.statsSessionLimit),
+    statsCacheSec: clampNumber(src.statsCacheSec, 0, 3600, d.statsCacheSec),
+    peakMultiplier: clampNumber(src.peakMultiplier, 1, 10, d.peakMultiplier),
+    priceFlash: normalizePriceOverride(src.priceFlash),
+    pricePro: normalizePriceOverride(src.pricePro),
+  };
+}
+
+/** 把设置折进 Cordis config，让既有的 resolvePricing / resolveApiKey / 统计逻辑无感读到。 */
+function withSettings(config, settings) {
+  const s = settings ?? DEFAULT_SETTINGS;
+  const priceByModel = {};
+  if (s.priceFlash) priceByModel["deepseek-v4-flash"] = s.priceFlash;
+  if (s.pricePro) priceByModel["deepseek-v4-pro"] = s.pricePro;
+  return {
+    ...config,
+    apiKey: s.apiKey !== "" ? s.apiKey : config?.apiKey,
+    peakMultiplier: s.peakMultiplier,
+    priceByModel,
+    statsSessionLimit: s.statsSessionLimit,
+    statsCacheMs: s.statsCacheSec * 1000,
+  };
+}
+
+/** 设置文件路径：优先 DSH 自己的 home（dshHomePath 服务），再环境变量，最后 ~/.dsh。
+ *  返回空串表示定位不到，此时读写一律静默降级为「用默认值、不落盘」。 */
+function settingsFilePath(ctx) {
+  let home = "";
+  try {
+    const svc = typeof ctx?.get === "function" ? ctx.get("dshHomePath") : null;
+    if (typeof svc === "string") home = svc;
+    else if (svc && typeof svc.path === "string") home = svc.path;
+    else if (svc && typeof svc.value === "string") home = svc.value;
+  } catch {
+    // 服务不存在或形状变了：走下面的兜底
+  }
+  if (home === "") home = String(process.env.DSH_HOME ?? "");
+  if (home === "") {
+    const base = process.env.USERPROFILE || process.env.HOME || "";
+    if (base !== "") home = `${base}${process.platform === "win32" ? "\\" : "/"}.dsh`;
+  }
+  if (home === "") return "";
+  const sep = home.includes("\\") && !home.includes("/") ? "\\" : "/";
+  return `${home.replace(/[\\/]+$/, "")}${sep}${SETTINGS_FILENAME}`;
+}
+
+/** 读设置文件；不存在 / JSON 损坏 / 无权限一律返回 null（调用方保持默认值）。 */
+async function readSettingsFile(file) {
+  if (file === "") return null;
+  try {
+    const { readFile } = await import("node:fs/promises");
+    const text = await readFile(file, "utf8");
+    return normalizeSettings(JSON.parse(text));
+  } catch {
+    return null;
+  }
+}
+
+/** 写设置文件：先写临时文件再改名，避免写一半把配置写坏。 */
+async function writeSettingsFile(file, settings) {
+  if (file === "") throw new Error("无法定位 DSH 配置目录");
+  const { mkdir, writeFile, rename } = await import("node:fs/promises");
+  const { dirname } = await import("node:path");
+  await mkdir(dirname(file), { recursive: true });
+  const tmp = `${file}.tmp`;
+  await writeFile(tmp, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+  await rename(tmp, file);
+}
+
+/** 读 HTTP 请求体（限制大小，避免被超大 body 拖垮）。 */
+function readRequestBody(req, limit = 64 * 1024) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += chunk.length;
+      if (size > limit) {
+        reject(new Error("请求体过大"));
+        if (typeof req.destroy === "function") req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+
 function beijingDayKey(timeMs) {
   return new Date(Number(timeMs) + 8 * 60 * 60 * 1000).toISOString().slice(0, 10);
 }
@@ -523,6 +731,7 @@ function tokenTotal(usage) {
 /** 按北京时间把一个会话的最终 assistant/message usage 聚合到每日统计。 */
 function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessionId) {
   const switches = collectModelSwitches(events);
+  const starts = stepStartTimes(events);
   const fallback = fallbackModel || "deepseek-v4-flash";
   const latestByStep = new Map();
   for (const event of events ?? []) {
@@ -531,7 +740,8 @@ function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessio
     const turn = event.data?.turn;
     const step = event.data?.step;
     if (usage == null || turn == null || step == null) continue;
-    latestByStep.set(`${turn}/${step}`, { usage, time: Number(event.time ?? 0) });
+    // 与 sumEventsUsage 同口径：按"请求发起时刻"归属日期与峰谷，拿不到才回退完成时刻
+    latestByStep.set(`${turn}/${step}`, { usage, time: starts.get(`${turn}/${step}`) ?? Number(event.time ?? 0) });
   }
   for (const { usage, time } of latestByStep.values()) {
     if (!Number.isFinite(time) || time < cutoffMs) continue;
@@ -558,7 +768,7 @@ function collectDailyUsage(events, config, fallbackModel, cutoffMs, days, sessio
     // 分时段精确计费：高峰桶按高峰价（= 目录价 ×2）、空闲桶按目录价
     const bucket = { peak: emptyTokenBucket(), offpeak: emptyTokenBucket() };
     addTokenUsage(isPeak ? bucket.peak : bucket.offpeak, usage);
-    const stepCost = estimateCost(bucket, resolvePricing(config, model, pricingEraAt(time)));
+    const stepCost = estimateCost(bucket, catalogPricing(config, model, pricingEraAt(time)), peakMultiplierOf(config));
 
     addTokenUsage(day, usage);
     const tokens = tokenTotal({
@@ -630,7 +840,7 @@ async function buildUsageStats(ctx, config) {
   }
   const selected = sessionIds
     .filter((id) => typeof id === "string" && id !== "")
-    .slice(0, STATS_MAX_SESSIONS);
+    .slice(0, clampNumber(config?.statsSessionLimit, 10, 2000, STATS_MAX_SESSIONS));
   const daily = new Map();
   let cursor = 0;
   let scannedSessions = 0;
@@ -823,16 +1033,16 @@ async function sumSubagentUsage(ctx, sessionId, config) {
   return { usage };
 }
 
-function formatUsage(usage, pricing, model = "") {
+function formatUsage(usage, pricing, multiplier = 2, model = "") {
   // 优先按 byModel 逐段累加（每段用各自模型 + 价格时代的价格，历史消耗不因调价而变）；
-  // 无 byModel 时回退单一价格估算（兼容旧数据）。
+  // 无 byModel 时回退单一价格估算（兼容旧数据）。pricing 是**目录价**，倍率单独传。
   const cost =
     Array.isArray(usage.byModel) && usage.byModel.length > 0
       ? usage.byModel.reduce(
-          (sum, b) => sum + (typeof b.cost === "number" && Number.isFinite(b.cost) ? b.cost : estimateCost(b, pricing)),
+          (sum, b) => sum + (typeof b.cost === "number" && Number.isFinite(b.cost) ? b.cost : estimateCost(b, pricing, multiplier)),
           0,
         )
-      : estimateCost(usage, pricing);
+      : estimateCost(usage, pricing, multiplier);
   const newTokens = usage.inputTokens + usage.outputTokens;
   const peakTokens = usage.peak.inputTokens + usage.peak.cacheReadTokens + usage.peak.cacheWriteTokens + usage.peak.outputTokens;
   const offpeakTokens = usage.offpeak.inputTokens + usage.offpeak.cacheReadTokens + usage.offpeak.cacheWriteTokens + usage.offpeak.outputTokens;
@@ -862,6 +1072,18 @@ function writeJson(res, status, payload) {
 
 export function apply(ctx, config = {}) {
   let statsCache = { expiresAt: 0, value: null };
+  // 用户设置（「插件」页配置卡片读写）：先按出厂默认值跑，异步读到文件后热替换。
+  // 读不到文件不是错误——全新安装就是没有文件，保持默认值即可。
+  const settingsState = { value: { ...DEFAULT_SETTINGS }, file: "" };
+  let effectiveConfig = withSettings(config, settingsState.value);
+  void (async () => {
+    settingsState.file = settingsFilePath(ctx);
+    const loaded = await readSettingsFile(settingsState.file);
+    if (loaded) {
+      settingsState.value = loaded;
+      effectiveConfig = withSettings(config, loaded);
+    }
+  })();
   // DSH 热重载(reload)时会重新 apply 本插件；若旧实例注册的 /balance-api 路由
   // 未被清理，新实例再次 register 就会抛出 duplicate route，导致整个 apply 失败、
   // 余额不显示。这里收集每次 register 返回的 disposer，并在插件卸载(ctx.on("dispose"))
@@ -883,20 +1105,21 @@ export function apply(ctx, config = {}) {
       name: "balance",
       description: "查询 DeepSeek 余额与当前会话消耗",
       handler: async ({ agent, signal }) => {
-        const usage = sumSessionUsage(agent.session, config);
+        const usage = sumSessionUsage(agent.session, effectiveConfig);
         const model = detectModel(agent.session);
-        const pricing = resolvePricing(config, model);
+        const pricing = catalogPricing(effectiveConfig, model);
+        const multiplier = peakMultiplierOf(effectiveConfig);
         // 余额来源：官方账号优先（官方版内置登录，无需 API Key），回退 API Key。
-        const { balance, error } = await resolveBalance(ctx, config, signal);
+        const { balance, error } = await resolveBalance(ctx, effectiveConfig, signal);
         if (balance === null) {
           return {
             kind: "error",
-            text: `${error}\n\n${formatUsage(usage, pricing, model)}`,
+            text: `${error}\n\n${formatUsage(usage, pricing, multiplier, model)}`,
           };
         }
         return {
           kind: "success",
-          text: `${formatBalance(balance)}\n\n${formatUsage(usage, pricing, model)}`,
+          text: `${formatBalance(balance)}\n\n${formatUsage(usage, pricing, multiplier, model)}`,
         };
       },
     });
@@ -912,6 +1135,40 @@ export function apply(ctx, config = {}) {
       kind: "exact",
       path: "/balance-api",
       handler: async (req, res) => {
+        // 配置读写：GET /balance-api?config=1 读设置，POST 同路径写设置。
+        // DSH「插件」页 → balance-dsh → 配置卡片（lib/client.js 注册的
+        // plugins.bundle.config）就走这两个入口。
+        let configParams = null;
+        try {
+          configParams = new URL(req.url, "http://localhost").searchParams;
+        } catch {
+          configParams = null;
+        }
+        if (configParams?.get("config") === "1") {
+          try {
+            if (req.method === "GET") {
+              writeJson(res, 200, { ok: true, settings: settingsState.value, version: PLUGIN_VERSION });
+              return;
+            }
+            if (req.method !== "POST") {
+              writeJson(res, 405, { ok: false, error: "method not allowed" });
+              return;
+            }
+            const body = await readRequestBody(req);
+            const parsed = body.trim() === "" ? {} : JSON.parse(body);
+            const patch = parsed != null && typeof parsed === "object" && parsed.settings != null ? parsed.settings : parsed;
+            const next = normalizeSettings({ ...settingsState.value, ...(patch ?? {}) });
+            await writeSettingsFile(settingsState.file || settingsFilePath(ctx), next);
+            settingsState.value = next;
+            effectiveConfig = withSettings(config, next);
+            // 价格与扫描范围可能变了，作废统计缓存
+            statsCache = { expiresAt: 0, value: null };
+            writeJson(res, 200, { ok: true, settings: next, version: PLUGIN_VERSION });
+          } catch (error) {
+            writeJson(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
+          }
+          return;
+        }
         if (req.method !== "GET") {
           writeJson(res, 405, { ok: false, error: "method not allowed" });
           return;
@@ -937,8 +1194,8 @@ export function apply(ctx, config = {}) {
           try {
             if (statsCache.value == null || statsCache.expiresAt <= Date.now()) {
               statsCache = {
-                value: await buildUsageStats(httpCtx, config),
-                expiresAt: Date.now() + STATS_CACHE_MS,
+                value: await buildUsageStats(httpCtx, effectiveConfig),
+                expiresAt: Date.now() + (effectiveConfig.statsCacheMs ?? STATS_CACHE_MS),
               };
             }
             stats = statsCache.value;
@@ -957,7 +1214,7 @@ export function apply(ctx, config = {}) {
             const sessions = ctx.get("sessions");
             const session = sessions && typeof sessions.get === "function" ? sessions.get(sessionParam) : void 0;
             if (session !== void 0) {
-              usage = sumSessionUsage(session, config);
+              usage = sumSessionUsage(session, effectiveConfig);
               detectedModel = detectModel(session);
             }
             // DSH 2.0.4 起 live session（sessions.get）可能拿不到 events，导致 usage 全 0。
@@ -966,7 +1223,7 @@ export function apply(ctx, config = {}) {
               try {
                 const persisted = await inspectPersistedSession(ctx, sessionParam);
                 if (Array.isArray(persisted?.events) && persisted.events.length > 0) {
-                  const persistedUsage = sumEventsUsage(persisted.events, config, detectedModel);
+                  const persistedUsage = sumEventsUsage(persisted.events, effectiveConfig, detectedModel);
                   if (persistedUsage.totalTokens > 0) {
                     usage = persistedUsage;
                     if (detectedModel === "") {
@@ -982,7 +1239,7 @@ export function apply(ctx, config = {}) {
             // 仍无任何 token 就返回 null，让客户端回退本地投影估算（而不是当成 0 消耗显示 ¥0.0000）
             if (usage != null && usage.totalTokens === 0) usage = null;
             // 子代理枚举走持久化目录（不依赖 live 会话），即使父会话不在内存也能拿到
-            const subRes = await sumSubagentUsage(httpCtx, sessionParam, config);
+            const subRes = await sumSubagentUsage(httpCtx, sessionParam, effectiveConfig);
             subagentUsage = subRes.usage;
           } catch {
             usage = null;
@@ -993,13 +1250,13 @@ export function apply(ctx, config = {}) {
         const effectiveModel = model || detectedModel;
         // 逐模型标注 cost（高峰期×2、空闲期×1），客户端直接按各模型 cost 累加，无需自己定价。
         if (usage && Array.isArray(usage.byModel)) {
-          usage.byModel = usage.byModel.map((b) => ({ ...b, cost: estimateCost(b, resolvePricing(config, b.model, b.era)) }));
+          usage.byModel = usage.byModel.map((b) => ({ ...b, cost: estimateCost(b, catalogPricing(effectiveConfig, b.model, b.era), peakMultiplierOf(effectiveConfig)) }));
         }
         if (subagentUsage && Array.isArray(subagentUsage.byModel)) {
-          subagentUsage.byModel = subagentUsage.byModel.map((b) => ({ ...b, cost: estimateCost(b, resolvePricing(config, b.model, b.era)) }));
+          subagentUsage.byModel = subagentUsage.byModel.map((b) => ({ ...b, cost: estimateCost(b, catalogPricing(effectiveConfig, b.model, b.era), peakMultiplierOf(effectiveConfig)) }));
         }
         // 余额来源：官方账号优先（官方桌面版内置登录，无需 API Key），回退 DeepSeek API Key。
-        const { balance, error: balanceError } = await resolveBalance(ctx, config);
+        const { balance, error: balanceError } = await resolveBalance(ctx, effectiveConfig);
         if (balance === null && !wantStats) {
           writeJson(res, 200, { ok: false, error: balanceError });
           return;
@@ -1008,7 +1265,9 @@ export function apply(ctx, config = {}) {
           ok: true,
           balance,
           balanceError: balance === null ? balanceError : null,
-          pricing: resolvePricing(config, effectiveModel),
+          // 传给客户端的是**目录价**（不含峰谷倍率）：客户端自己按高峰时段乘倍率，
+          // 若这里给 resolvePricing（已乘倍率）客户端会再乘一次，金额虚高约 3 倍。
+          pricing: catalogPricing(effectiveConfig, effectiveModel),
           model: effectiveModel,
           usage,
           subagentUsage,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "balance-dsh",
-  "version": "1.2.2",
-  "description": "查询 DeepSeek 余额并显示当前会话 token 消耗。DeepSeek 账户余额 + 会话 token/费用显示，含高峰/空闲峰谷计费。",
+  "version": "1.3.0",
+  "description": "在 DSH 中显示 DeepSeek 账户余额和当前会话 token/费用消耗（含高峰/空闲峰谷计费）。仅支持 DeepSeek 官方模型与账号，暂不支持其他大模型。",
   "author": "Rannist",
   "type": "module",
   "main": "lib/index.js",