dsh-all-usage 1.1.17 → 1.2.0

package/lib/usage-core.js

@@ -37,7 +37,7 @@ export function normalizeUsageValues(usage) {
   }
 }
 
-export function hasUsageValues(values) {
+function hasUsageValues(values) {
   return values !== null && values !== undefined && (values.input > 0 || values.output > 0 || values.cacheRead > 0 || values.cacheWrite > 0 || values.reasoning > 0)
 }
 
@@ -114,17 +114,39 @@ export function usageStepKey(sid, data, seq, fallback) {
   return safeSid + ':event:' + (serialized === undefined ? String(fallback === undefined ? '' : fallback) : serialized)
 }
 
-/** Recalculate the billing instant for a re-priced sample, preferring the recorded request time. */
-export function billingInstantOf(item, oldCost) {
+/**
+ * A context stamp describes one request, and DSH can emit `request/context` once
+ * per session rather than once per call: reading such a stamp back prices an
+ * evening request inside the morning peak window. Anything older than this is not
+ * the request being billed, so the usage event's own time is used instead.
+ */
+export const MAX_CONTEXT_AGE_MS = 30 * 60 * 1000
+
+/** True when a context stamp is close enough to the event to belong to it. */
+export function contextTimeIsFresh(candidate, eventTime) {
+  return Number.isFinite(candidate) && validEventTime(eventTime) && candidate <= eventTime && eventTime - candidate <= MAX_CONTEXT_AGE_MS
+}
+
+/**
+ * Recalculate the billing instant for a re-priced sample, preferring the recorded
+ * request time. `trusted` is false when the caller proved the recorded stamp was
+ * a stale session-level context rather than this request's own.
+ */
+export function billingInstantOf(item, oldCost, trusted = true) {
   const oldAt = oldCost != null && Number.isFinite(oldCost.pricingAt) ? oldCost.pricingAt : null
-  const at = Number.isFinite(item.pricingAt) ? item.pricingAt : oldAt !== null ? oldAt : validEventTime(item.time) ? item.time : null
+  const itemTime = item !== null && typeof item === 'object' ? item.time : undefined
+  const itemAt = item !== null && typeof item === 'object' && Number.isFinite(item.pricingAt) ? item.pricingAt : null
+  const at = trusted
+    ? (itemAt !== null ? itemAt : oldAt !== null ? oldAt : validEventTime(itemTime) ? itemTime : null)
+    : (validEventTime(itemTime) ? itemTime : oldAt)
   const oldSource = oldCost != null && (oldCost.pricingTimeSource === 'request-context' || oldCost.pricingTimeSource === 'usage-event') ? oldCost.pricingTimeSource : null
-  const source = typeof item.pricingTimeSource === 'string' && (item.pricingTimeSource === 'request-context' || item.pricingTimeSource === 'usage-event') ? item.pricingTimeSource : (oldSource || 'usage-event')
+  const recordedSource = typeof item.pricingTimeSource === 'string' && (item.pricingTimeSource === 'request-context' || item.pricingTimeSource === 'usage-event') ? item.pricingTimeSource : (oldSource || 'usage-event')
+  const source = trusted ? recordedSource : 'usage-event'
   return { at, source }
 }
 
 /** Bounded context archive shared by the live fold and the persisted ledger. */
-export const MAX_CONTEXT_TIMES = 512
+const MAX_CONTEXT_TIMES = 512
 
 /** Insert-or-refresh a context entry with real LRU eviction (delete + set). */
 export function touchContextTimes(times, key, time) {
@@ -150,10 +172,11 @@ export function contextTimeKey(turn, step) {
 export function pickPricingTime(contextTimes, eventTime, turn, step) {
   if (contextTimes instanceof Map && validEventTime(eventTime)) {
     const exact = contextTimes.get(contextTimeKey(turn, step))
-    const candidate = exact !== undefined ? exact : contextTimes.get(contextTimeKey(null, null))
-    if (Number.isFinite(candidate) && candidate <= eventTime) {
-      return { time: candidate, source: 'request-context' }
-    }
+    if (Number.isFinite(exact) && exact <= eventTime) return { time: exact, source: 'request-context' }
+    // The session-level fallback is only this request's context while it is recent;
+    // an old one would price the call in a window it never ran in.
+    const latest = contextTimes.get(contextTimeKey(null, null))
+    if (contextTimeIsFresh(latest, eventTime)) return { time: latest, source: 'request-context' }
   }
   return { time: Number.isFinite(eventTime) && eventTime >= 0 ? eventTime : null, source: 'usage-event' }
 }

package/lib/version-check.js

@@ -0,0 +1,133 @@
+// Version check for the dashboard header. The running version is known locally;
+// this only asks the npm registry for the newest published one, at most once per
+// TTL and only while a dashboard is open (the page asks for it, the host never
+// polls on its own). A plain GET of a small JSON document, no body, no cookies.
+const VERSION_CHECK_URL = 'https://registry.npmjs.org/dsh-all-usage/latest'
+const VERSION_CHECK_TTL_MS = 6 * 60 * 60 * 1000
+const VERSION_CHECK_TIMEOUT_MS = 8000
+// The route is a plain local read (like /api/all-usage/status it needs no
+// capability), so this floor is what keeps one page - or a hostile local page -
+// from turning a burst of requests into a burst of registry requests.
+const VERSION_CHECK_MIN_INTERVAL_MS = 30 * 1000
+const MAX_VERSION_BYTES = 64 * 1024
+
+function parseVersion(text) {
+  const value = String(text === undefined || text === null ? '' : text).trim().replace(/^v/, '')
+  const match = value.match(/^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/)
+  if (match === null) return null
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] === undefined ? null : match[4].split('.'),
+  }
+}
+
+/**
+ * Compare two dotted versions the way semver orders them: numeric parts first,
+ * then a prerelease ranks below its release and numeric identifiers rank below
+ * alphanumeric ones ('1.1.18-rc.1' < '1.1.18' < '1.1.19'). Returns -1, 0 or 1,
+ * and 0 for anything unparseable so a malformed tag never claims an update.
+ */
+export function compareVersions(left, right) {
+  const a = parseVersion(left)
+  const b = parseVersion(right)
+  if (a === null || b === null) return 0
+  for (const key of ['major', 'minor', 'patch']) {
+    if (a[key] !== b[key]) return a[key] < b[key] ? -1 : 1
+  }
+  if (a.prerelease === null && b.prerelease === null) return 0
+  if (a.prerelease === null) return 1
+  if (b.prerelease === null) return -1
+  const length = Math.max(a.prerelease.length, b.prerelease.length)
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = a.prerelease[index]
+    const rightPart = b.prerelease[index]
+    if (leftPart === undefined) return -1
+    if (rightPart === undefined) return 1
+    if (leftPart === rightPart) continue
+    const leftNumber = /^\d+$/.test(leftPart) ? Number(leftPart) : null
+    const rightNumber = /^\d+$/.test(rightPart) ? Number(rightPart) : null
+    if (leftNumber !== null && rightNumber !== null) return leftNumber < rightNumber ? -1 : 1
+    if (leftNumber !== null) return -1
+    if (rightNumber !== null) return 1
+    return leftPart < rightPart ? -1 : 1
+  }
+  return 0
+}
+
+/** 'latest' when the running version is at least the published one, else 'outdated'. */
+export function versionStatus(current, latest) {
+  if (typeof current !== 'string' || current === '') return 'unknown'
+  if (typeof latest !== 'string' || latest === '') return 'unknown'
+  if (parseVersion(current) === null || parseVersion(latest) === null) return 'unknown'
+  return compareVersions(current, latest) < 0 ? 'outdated' : 'latest'
+}
+
+export async function fetchLatestVersion(fetchImpl = globalThis.fetch, options = {}) {
+  if (typeof fetchImpl !== 'function') return { ok: false, error: 'fetch-unavailable' }
+  const url = typeof options.url === 'string' && options.url !== '' ? options.url : VERSION_CHECK_URL
+  const timeoutMs = Number.isFinite(options.timeoutMs) && options.timeoutMs > 0 ? options.timeoutMs : VERSION_CHECK_TIMEOUT_MS
+  let controller = null
+  let timer = null
+  try {
+    if (typeof AbortController === 'function') {
+      controller = new AbortController()
+      timer = setTimeout(() => controller.abort(), timeoutMs)
+    }
+    const response = await fetchImpl(url, { headers: { accept: 'application/json' }, signal: controller ? controller.signal : undefined })
+    if (!response || response.ok !== true) return { ok: false, error: 'http-' + String((response && response.status) || 0) }
+    const text = await response.text()
+    if (new TextEncoder().encode(text).length > MAX_VERSION_BYTES) return { ok: false, error: 'version-too-large' }
+    let parsed = null
+    try { parsed = JSON.parse(text.replace(/^\uFEFF/, '')) } catch (err) { return { ok: false, error: 'version-invalid-json' } }
+    const version = parsed !== null && typeof parsed === 'object' && typeof parsed.version === 'string' ? parsed.version.trim() : ''
+    if (parseVersion(version) === null) return { ok: false, error: 'version-invalid' }
+    return { ok: true, version, sourceUrl: url, fetchedAt: Date.now() }
+  } catch (err) {
+    return { ok: false, error: 'version-fetch-failed' }
+  } finally {
+    if (timer !== null) clearTimeout(timer)
+  }
+}
+
+export function createVersionCheck(options = {}) {
+  const fetchImpl = options.fetchImpl === undefined ? globalThis.fetch : options.fetchImpl
+  const currentVersion = typeof options.currentVersion === 'string' ? options.currentVersion : ''
+  const ttlMs = Number.isFinite(options.ttlMs) && options.ttlMs > 0 ? options.ttlMs : VERSION_CHECK_TTL_MS
+  const minIntervalMs = Number.isFinite(options.minIntervalMs) && options.minIntervalMs >= 0 ? options.minIntervalMs : VERSION_CHECK_MIN_INTERVAL_MS
+  let entry = null
+  let failure = null
+  let lastAttemptAt = 0
+  function snapshot(cached) {
+    return {
+      current: currentVersion,
+      latest: entry === null ? null : entry.version,
+      status: entry === null ? 'unknown' : versionStatus(currentVersion, entry.version),
+      checkedAt: entry === null ? null : entry.fetchedAt,
+      sourceUrl: entry === null ? VERSION_CHECK_URL : entry.sourceUrl,
+      error: failure === null ? null : failure.error,
+      cached: cached === true,
+    }
+  }
+  /** Read the cached verdict, or ask the registry again when it is stale or forced. */
+  async function read(force) {
+    const now = Date.now()
+    if (!force && entry !== null && now - entry.fetchedAt < ttlMs) return snapshot(true)
+    // A forced read still waits out the floor: force comes from the refresh button,
+    // and no human needs a second registry round trip inside the same half minute.
+    if (lastAttemptAt > 0 && now - lastAttemptAt < minIntervalMs) return snapshot(false)
+    lastAttemptAt = now
+    const result = await fetchLatestVersion(fetchImpl, options)
+    if (result.ok) {
+      entry = { version: result.version, fetchedAt: result.fetchedAt, sourceUrl: result.sourceUrl }
+      failure = null
+    } else {
+      failure = { error: result.error, failedAt: Date.now() }
+    }
+    return snapshot(false)
+  }
+  return { read, snapshot: () => snapshot(true), currentVersion }
+}
+
+export { VERSION_CHECK_MIN_INTERVAL_MS, VERSION_CHECK_TTL_MS, VERSION_CHECK_URL }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-all-usage",
-  "version": "1.1.17",
+  "version": "1.2.0",
   "description": "DeepSeek Harness usage dashboard with model, provider, workspace, cache, balance, and CSV insights",
   "repository": {
     "type": "git",
@@ -31,8 +31,8 @@
   },
   "dsh": {
     "compatibility": {
-      "runtime": ">=0.1.1-rc.1 <0.1.5-0 || >=0.1.5-rc.1 <0.1.6-0 || >=0.1.7-rc.2 <0.1.8-0 || >=0.2.0-rc.2 <0.2.1-0",
-      "verified": ["0.2.0-rc.2", "0.1.7-rc.2", "0.1.5-rc.2", "0.1.5-rc.1", "0.1.1-rc.2", "0.1.1-rc.1"]
+      "runtime": ">=0.1.1-rc.1 <0.1.5-0 || >=0.1.5-rc.1 <0.1.6-0 || >=0.1.7-rc.2 <0.1.8-0 || >=0.2.0-rc.2 <0.2.1-0 || 0.2.1-alpha.2",
+      "verified": ["0.2.1-alpha.2", "0.2.0-rc.2", "0.1.7-rc.2", "0.1.5-rc.2", "0.1.5-rc.1", "0.1.1-rc.2", "0.1.1-rc.1"]
     },
     "bundle": {
       "patch": "./cordis.patch.yml"
@@ -50,6 +50,7 @@
     "lib/index.js",
     "lib/plugin.js",
     "lib/aggregation.js",
+    "lib/records-cache.js",
     "lib/ledger.js",
     "lib/session-sync.js",
     "lib/pricing-runtime.js",
@@ -58,7 +59,11 @@
     "lib/client.js",
     "lib/pricing.js",
     "lib/usage-core.js",
+    "lib/version-check.js",
+    "lib/icons.js",
     "CHANGELOG.md",
+    "README.md",
+    "README.en.md",
     "cordis.patch.yml",
     "screenshots.json",
     "fixtures/usage-events.json",

package/screenshots.json

@@ -1,5 +1,12 @@
 [
-  "assets/screenshot-1.png",
-  "assets/screenshot-2.png",
-  "assets/screenshot-3.png"
+  "assets/screenshots/zh/01-overview.png",
+  "assets/screenshots/zh/02-heatmap.png",
+  "assets/screenshots/zh/03-model-usage.png",
+  "assets/screenshots/zh/04-request-logs.png",
+  "assets/screenshots/zh/05-cost-settings.png",
+  "assets/screenshots/en/01-overview.png",
+  "assets/screenshots/en/02-heatmap.png",
+  "assets/screenshots/en/03-model-usage.png",
+  "assets/screenshots/en/04-request-logs.png",
+  "assets/screenshots/en/05-cost-settings.png"
 ]