@mzzsfy/dsh-usage-panel 0.5.0 → 0.6.0

package/README.md

@@ -40,8 +40,8 @@ dsh plugin --profile web add @mzzsfy/dsh-usage-panel
 
 ## 定期查询与趋势(v2)
 
-- 定期查询:时间驱动调度——每账号按读数档位定档,含 5 小时窗口的账号每 10 分钟查询一次(= 短窗口快照粒度),其余账号每小时一次(= 长窗口快照粒度);上次尝试查询时刻随配置持久化,宿主重启后调度无缝衔接。定时轮询为软依赖:宿主 timer 服务不可用时仅停用自动轮询,面板显示降级提示,手动查询与全部配置能力不受影响
-- 失败退避:单账号失败按指数退避(基期 = 账号档位间隔,×2 封顶 8 倍),成功即恢复;失败账号按短档节奏(10 分钟)调度重试,退避指数压制实际频率,避免一次瞬时失败造成短窗序列长时间空洞。退避与档位到点独立叠加,二者皆过才发起查询。面板打开触发的自动查询同样受退避约束,手动刷新不受限
+- 定期查询:时间驱动调度——全账号统一每 10 分钟查询一次(余额阈值等通知最长延迟约 10 分钟);上次尝试查询时刻随配置持久化,宿主重启后调度无缝衔接。定时轮询为软依赖:宿主 timer 服务不可用时仅停用自动轮询,面板显示降级提示,手动查询与全部配置能力不受影响
+- 失败退避:单账号失败按指数退避(基期 = 统一查询间隔,×2 封顶 8 倍),成功即恢复。退避与到点判定独立叠加,二者皆过才发起查询。面板打开触发的自动查询同样受退避约束,手动刷新不受限
 - 历史快照:按序列分档落盘 `history.json`(5 小时滚动 → 10 分钟粒度留 7 天;7 天 / 月 / 余额 → 小时粒度留 30 天),档内去重,超期修剪,硬点数上限兜底;删除账号时其历史序列同步清理
 - 趋势视图:悬浮账号卡片弹出 sparkline(自绘 SVG),短 / 长窗口独立成图,绝对值 / 差值双视角;「详情」对话框可切时间范围(长窗口 / 月 / 余额:近 7 天 / 30 天 / 全部;5 小时短窗口仅近 7 天 / 全部),含区间摘要与明细表
 - 历史文件解析失败时自动备份为 `history.json.bak` 并暂停写入(防空数据覆盖);`history.json` 被移除或恢复为可解析内容后自动恢复写入,`.bak` 是损坏前的最后数据,删除前请确认不再需要。`accounts.json` 同构守卫:损坏时备份为 `accounts.json.bak` 并拒绝一切写入(防账号 Key 被空配置覆盖),恢复后解除

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-usage-panel",
   "description": "多平台 LLM 账号余额与额度面板:支持 DeepSeek/OpenRouter/Kimi/智谱/MiniMax/NewApi 及自定义端点,自动定期查询,趋势图与历史快照,用量/余额阈值与窗口重置多通道通知",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/index.js

@@ -16,7 +16,7 @@ import {
 } from './parsers.mjs'
 import { readingToSnapshots, appendPoint, buildMonthSequence, newSequenceStore } from './history.mjs'
 import { createHistoryStore } from './historyStore.mjs'
-import { createBackoff, isShortWindowTier, tierIntervalSec, lastQuerySecOf, isDue, runLimited } from './poller.mjs'
+import { createBackoff, lastQuerySecOf, isDue, runLimited, POLL_INTERVAL_SEC } from './poller.mjs'
 import {
   DEFAULT_QUOTA_THRESHOLD_PCT,
   WEBHOOK_TIMEOUT_MS,
@@ -51,7 +51,6 @@ const HISTORY_FILE = join(DATA_DIR, 'history.json')
 const BAK_SUFFIX = '.bak'
 const ACCOUNTS_BROKEN_MESSAGE = '账号配置文件已损坏已备份,已暂停写入以防数据丢失'
 const TICK_SEC = 30
-const SHORT_SUFFIX = '5h'
 
 const NAMESPACE = 'usage-panel'
 
@@ -334,9 +333,8 @@ export function apply(ctx) {
   let accountsBroken = false
   let historyStore = createHistoryStore({ file: HISTORY_FILE })
   let history = newSequenceStore()
-  // 账号级档位退避状态:基期随读数档位翻转重建;调度到点由 last.queriedAt + 档位间隔另行判定
-  const pollState = new Map()
-  // 通知投影(client 轮询展示)与事件序号
+  // 账号级退避状态:每账号失败计数独立,只管退避不管调度;调度到点由 last.queriedAt + 统一间隔另行判定
+  const pollState = new Map()  // 通知投影(client 轮询展示)与事件序号
   const projection = createProjection({})
   let notifySeq = 0
 
@@ -367,37 +365,28 @@ export function apply(ctx) {
     return persistHistory()
   }
 
-  // 账号级退避状态:基期 = 账号档位间隔(读数档位翻转时重建),只管退避不管调度
+  // 账号级退避状态:基期 = 统一查询间隔,每账号失败计数独立,只管退避不管调度
   function pollEntry(account) {
-    const baseSec = tierIntervalSec(hasShortWindow(account))
     const existing = pollState.get(account.id)
-    if (existing && existing.baseSec === baseSec) return existing
-    const state = { baseSec, backoff: createBackoff({ baseSec }) }
-    pollState.set(account.id, state)
-    return state
-  }
-
-  function hasShortWindow(account) {
-    return isShortWindowTier(
-      account.last,
-      account.last !== null && account.last.reading !== null &&
-        readingToSnapshots(account.last.reading).some((snap) => snap.suffix === SHORT_SUFFIX),
-    )
+    if (existing) return existing
+    const backoff = createBackoff({ baseSec: POLL_INTERVAL_SEC })
+    pollState.set(account.id, backoff)
+    return backoff
   }
 
   function runQuery(account) {
     const queriedAt = Date.now()
     return queryAccount(account).then((result) => {
-      const state = pollEntry(account)
+      const backoff = pollEntry(account)
       if (result.ok) {
-        state.backoff.onSuccess()
+        backoff.onSuccess()
         // 先评估后落盘:阈值穿越事件不因落盘失败丢失;落盘失败仅弃本轮快照
         evaluateAndDispatch(account, queriedAt)
         return recordSnapshots(account, account.last.reading, queriedAt)
           .catch(() => {})
           .then(() => result)
       }
-      state.backoff.onFailure(Math.floor(queriedAt / 1000))
+      backoff.onFailure(Math.floor(queriedAt / 1000))
       return result
     })
   }
@@ -538,7 +527,7 @@ export function apply(ctx) {
           const account = current.accounts.find((item) => item.id === id)
           requireOk(account !== undefined, '账号不存在: ' + id)
           // 面板打开触发的自动查询受退避约束,避免绕过退避轰炸上游;手动刷新不受限
-          if (auto && pollEntry(account).backoff.isBlocked(Math.floor(Date.now() / 1000))) {
+          if (auto && pollEntry(account).isBlocked(Math.floor(Date.now() / 1000))) {
             sendJson(res, 200, { ok: false, skipped: true, account: redactAccount(account) })
             return
           }
@@ -730,7 +719,7 @@ export function apply(ctx) {
   )
 
   // 定期轮询:固定短 tick,时间驱动调度——上次尝试查询时刻(account.last.queriedAt,
-  // 成功失败均记、随配置持久化)距今超过账号档位间隔即到点;退避独立叠加,二者皆过才查。
+  // 成功失败均记、随配置持久化)距今超过统一查询间隔即到点;退避独立叠加,二者皆过才查。
   // 旧 round 分频形态已废:round 仅查询时递增使余额类账号死锁停摆,短窗账号每 tick 必查
   // 使间隔设置失效。
   // timer 软依赖经嵌套 inject 等待:服务激活才武装轮询,缺失则自动轮询停用,
@@ -748,11 +737,11 @@ export function apply(ctx) {
       if (!current) return
       const nowSec = Math.floor(Date.now() / 1000)
       const due = current.accounts.filter((account) => {
-        if (pollEntry(account).backoff.isBlocked(nowSec)) return false
+        if (pollEntry(account).isBlocked(nowSec)) return false
         return isDue({
           lastQuerySec: lastQuerySecOf(account.last),
           nowSec,
-          intervalSec: tierIntervalSec(hasShortWindow(account)),
+          intervalSec: POLL_INTERVAL_SEC,
         })
       })
       if (due.length === 0) return

package/src/poller.mjs

@@ -1,15 +1,15 @@
-// 轮询纯逻辑层:时间驱动调度 / 失败指数退避 / 档位间隔。无 IO,host 半区与单测共用。
+// 轮询纯逻辑层:时间驱动调度 / 失败指数退避 / 统一查询间隔。无 IO,host 半区与单测共用。
 // 历史教训:旧 round 分频形态(round 仅在查询时递增)构成死锁——余额类账号首查后
 // round 恒 1 永不再查;短窗账号每 tick 必查使用户间隔设置完全失效。改为时间驱动:
-// 上次尝试查询时刻(成功失败均记)+ 档位间隔判定到点,退避独立叠加。
+// 上次尝试查询时刻(成功失败均记)+ 统一间隔判定到点,退避独立叠加。
+// 旧档位间隔(短窗 10 分钟/余额 1 小时)已统一为单一间隔:通知及时性要求余额类
+// 账号同节奏,两档常量相等后档位机制退化为恒同值死路径,整体移除。
 
 export const BACKOFF_CAP_MULTIPLE = 8
-// 短窗口档(5h 序列)查询间隔 = 序列快照粒度(history.mjs GRANULARITY_MS['10m'])
-export const SHORT_TIER_INTERVAL_SEC = 10 * 60
-// 长窗口档(日/月/余额序列)查询间隔 = 序列快照粒度(history.mjs GRANULARITY_MS['1h'])
-export const LONG_TIER_INTERVAL_SEC = 60 * 60
+// 全账号统一查询间隔
+export const POLL_INTERVAL_SEC = 10 * 60
 
-// 失败退避状态机:基期 = 账号档位间隔,×2 封顶;成功即恢复。
+// 失败退避状态机:基期 = 统一查询间隔,×2 封顶;成功即恢复。
 export function createBackoff({ baseSec }) {
   let failures = 0
   let nextRetryAt = null
@@ -32,19 +32,6 @@ export function createBackoff({ baseSec }) {
   }
 }
 
-// 短窗口档账号判定:从未查询成功(含最近一次失败)或最近成功读数含短窗序列。
-// 失败归短档:保持 10 分钟调度节奏与 600s 退避基期,避免一次瞬时失败把含 5h
-// 窗口的账号塌缩到 1 小时档,造成短窗序列长时间空洞;轰炸由退避指数压制。
-export function isShortWindowTier(last, readingHasShort) {
-  if (last === null) return true
-  return last.ok !== true || readingHasShort
-}
-
-// 账号档位间隔:含短窗口序列走短档,否则长档。
-export function tierIntervalSec(hasShortWindow) {
-  return hasShortWindow ? SHORT_TIER_INTERVAL_SEC : LONG_TIER_INTERVAL_SEC
-}
-
 // 上次尝试查询时刻(秒):queriedAt 毫秒历元;缺失/非法(旧数据)回 null 视为立即到点。
 export function lastQuerySecOf(last) {
   const queriedAt = last !== null && typeof last === 'object' ? last.queriedAt : undefined

package/test/poller.test.mjs

@@ -1,17 +1,16 @@
-// 轮询纯逻辑 BDD:时间驱动调度 / 失败退避 / 档位间隔。无外部依赖,定时器由调用方注入。
+// 轮询纯逻辑 BDD:时间驱动调度 / 失败退避 / 统一查询间隔。无外部依赖,定时器由调用方注入。
 // 历史:round 分频形态(shouldQueryThisRound/longWindowDivisor)已被时间驱动取代——
 // round 仅查询时递增使余额类账号死锁停摆,短窗账号每 tick 必查使用户间隔失效。
+// 档位间隔(短档 10 分钟/长档 1 小时)已被统一间隔取代——通知及时性要求余额类账号
+// 与短窗账号同节奏,两档常量相等后档位机制退化为恒同值死路径,整体移除。
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import {
   BACKOFF_CAP_MULTIPLE,
-  SHORT_TIER_INTERVAL_SEC,
-  LONG_TIER_INTERVAL_SEC,
+  POLL_INTERVAL_SEC,
   createBackoff,
-  tierIntervalSec,
   lastQuerySecOf,
   isDue,
-  isShortWindowTier,
   runLimited,
 } from '../src/poller.mjs'
 
@@ -45,11 +44,8 @@ test('场景: 退避期间被跳过,到期放行', () => {
   assert.equal(backoff.isBlocked(600), false)
 })
 
-test('场景: 档位间隔 = 序列快照粒度(短档 10 分钟,长档 1 小时)', () => {
-  assert.equal(SHORT_TIER_INTERVAL_SEC, 10 * 60)
-  assert.equal(LONG_TIER_INTERVAL_SEC, 60 * 60)
-  assert.equal(tierIntervalSec(true), SHORT_TIER_INTERVAL_SEC)
-  assert.equal(tierIntervalSec(false), LONG_TIER_INTERVAL_SEC)
+test('场景: 统一查询间隔 10 分钟,余额类账号与短窗账号同节奏', () => {
+  assert.equal(POLL_INTERVAL_SEC, 10 * 60)
 })
 
 test('场景: 上次尝试查询时刻换算,缺失或非法回 null 视为立即到点', () => {
@@ -65,29 +61,19 @@ test('场景: 时间驱动到点判定', () => {
   assert.equal(isDue({ lastQuerySec: null, nowSec: 1000, intervalSec: 600 }), true, '从未查询立即到点')
   assert.equal(isDue({ lastQuerySec: 500, nowSec: 1099, intervalSec: 600 }), false, '未满间隔')
   assert.equal(isDue({ lastQuerySec: 500, nowSec: 1100, intervalSec: 600 }), true, '恰满间隔到点')
-  assert.equal(isDue({ lastQuerySec: 0, nowSec: LONG_TIER_INTERVAL_SEC, intervalSec: LONG_TIER_INTERVAL_SEC }), true)
+  assert.equal(isDue({ lastQuerySec: 0, nowSec: POLL_INTERVAL_SEC, intervalSec: POLL_INTERVAL_SEC }), true)
 })
 
 test('场景: 退避与到点独立叠加,双过才查(时序推演锁定)', () => {
-  // 短窗账号失败:退避基期 = 档间隔 600;首次失败后 600s 内到点亦被退避压住
-  const backoff = createBackoff({ baseSec: SHORT_TIER_INTERVAL_SEC })
+  // 失败:退避基期 = 统一间隔;首次失败后一个周期内到点亦被退避压住
+  const backoff = createBackoff({ baseSec: POLL_INTERVAL_SEC })
   backoff.onFailure(1000)
   const dueAt = (lastQuerySec, nowSec) =>
-    !backoff.isBlocked(nowSec) && isDue({ lastQuerySec, nowSec, intervalSec: SHORT_TIER_INTERVAL_SEC })
+    !backoff.isBlocked(nowSec) && isDue({ lastQuerySec, nowSec, intervalSec: POLL_INTERVAL_SEC })
   assert.equal(dueAt(400, 1500), false, '退避未过(到 1600 才解),尽管 1000 已到点')
   assert.equal(dueAt(400, 1600), true, '退避与到点双过')
 })
 
-test('场景: 短窗口档判定,从未成功(含最近失败)按短档,失败不塌缩到长档', () => {
-  const readingHasShort = true
-  assert.equal(isShortWindowTier(null, readingHasShort), true, 'last 为空视为短窗口档')
-  assert.equal(isShortWindowTier(null, false), true, 'last 为空即使无短窗口读数也首轮即查')
-  assert.equal(isShortWindowTier({ ok: true, reading: {} }, readingHasShort), true)
-  assert.equal(isShortWindowTier({ ok: true, reading: {} }, false), false, '成功且仅长窗口按长档')
-  assert.equal(isShortWindowTier({ ok: false, reading: null }, readingHasShort), true, '失败不塌缩:含短窗账号保持短档节奏')
-  assert.equal(isShortWindowTier({ ok: false, reading: null }, false), true, '失败的长窗账号也归短档:10 分钟节奏 + 退避压制重试')
-})
-
 test('场景: 受限并发执行——全项被处理,慢任务不阻塞其他 worker', async () => {
   // Given 6 项任务,并发 2:每个任务挂起直到放行;并发内慢任务(后放行)只占 1 个 worker 位
   const processed = []