@dijkspicy/opencode-stats-reporter 0.1.0

package/src/paths.js

@@ -0,0 +1,37 @@
+import os from "node:os"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const HERE = path.dirname(fileURLToPath(import.meta.url))
+export const PKG_ROOT = path.resolve(HERE, "..")
+
+export function configDir() {
+  const base = process.env.MONITOR_CONFIG_DIR || path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "opencode-stats-reporter")
+  return base
+}
+
+export function dataDir() {
+  const base = process.env.MONITOR_DATA_DIR || path.join(process.env.XDG_DATA_HOME || path.join(os.homedir(), ".local", "share"), "opencode-stats-reporter")
+  return base
+}
+
+export function configFile() {
+  return path.join(configDir(), "config.json")
+}
+
+export function dbFile() {
+  return path.join(dataDir(), "monitor.db")
+}
+
+export function panelDir() {
+  return path.join(PKG_ROOT, "panel")
+}
+
+export function pluginSource() {
+  return path.join(PKG_ROOT, "contrib", "opencode-session-reporter", "session-usage-reporter.ts")
+}
+
+export function opencodePluginsDir() {
+  const base = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), ".config", "opencode")
+  return path.join(base, "plugins")
+}

package/src/proxy.js

@@ -0,0 +1,31 @@
+/** 把用量类请求反代到上游网关；鉴权只在本进程内附加，不暴露给浏览器。 */
+export function createProxy({ gatewayBaseUrl, apiKey }) {
+  return async function proxy(req, res, url) {
+    const target = gatewayBaseUrl.replace(/\/+$/, "") + url.pathname + (url.search || "")
+    const headers = { authorization: "Bearer " + apiKey }
+    if (req.headers["content-type"]) headers["content-type"] = req.headers["content-type"]
+    const init = { method: req.method, headers }
+    if (req.method !== "GET" && req.method !== "HEAD") init.body = await readBody(req)
+    let upstream
+    try {
+      upstream = await fetch(target, init)
+    } catch (err) {
+      res.writeHead(502, { "content-type": "application/json; charset=utf-8" })
+      res.end(JSON.stringify({ error: { message: "上游网关不可达: " + err.message, type: "upstream_error", code: "gateway_unreachable" } }))
+      return
+    }
+    const buf = Buffer.from(await upstream.arrayBuffer())
+    const outHeaders = { "content-type": upstream.headers.get("content-type") || "application/json; charset=utf-8" }
+    res.writeHead(upstream.status, outHeaders)
+    res.end(buf)
+  }
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    req.on("data", (c) => chunks.push(c))
+    req.on("end", () => resolve(Buffer.concat(chunks)))
+    req.on("error", reject)
+  })
+}

package/src/server.js

@@ -0,0 +1,164 @@
+import http from "node:http"
+import fs from "node:fs"
+import path from "node:path"
+import { ApiError, report, listSessions, sessionDetail, sessionsSummary } from "./session-api.js"
+import { createProxy } from "./proxy.js"
+import { createIdentityResolver } from "./identity.js"
+
+const MAX_BODY = 1024 * 1024
+
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+}
+
+// 本地模式：把面板运行配置指向本地源，并清掉可能覆盖它的 localStorage 键
+const INJECT = `<script>(function(){try{
+window.APP_CONFIG=Object.assign({},window.APP_CONFIG||{},{gatewayBaseUrl:location.origin,apiKey:"local"});
+var k="blueregion-usage.config.v1";var raw=localStorage.getItem(k);
+if(raw){var o=JSON.parse(raw)||{};delete o.gatewayBaseUrl;delete o.apiKey;localStorage.setItem(k,JSON.stringify(o));}
+}catch(e){}})();</script>`
+
+export function injectConfig(html) {
+  const marker = '<script src="config.js"></script>'
+  if (html.includes(marker)) return html.replace(marker, INJECT + "\n" + marker)
+  return html.replace("</head>", INJECT + "\n</head>")
+}
+
+function sendJson(res, status, payload) {
+  const body = Buffer.from(JSON.stringify(payload), "utf8")
+  res.writeHead(status, { "content-type": "application/json; charset=utf-8", "content-length": body.length })
+  res.end(body)
+}
+
+function sendError(res, status, message, code, type = "invalid_request_error") {
+  sendJson(res, status, { error: { message, type, code } })
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    let size = 0
+    req.on("data", (c) => {
+      size += c.length
+      if (size > MAX_BODY) {
+        reject(new ApiError(413, "请求体超过上限", "body_too_large"))
+        req.destroy()
+        return
+      }
+      chunks.push(c)
+    })
+    req.on("end", () => resolve(Buffer.concat(chunks)))
+    req.on("error", reject)
+  })
+}
+
+export function createServer({ config, store, panelDir, mode = "local", consumerHeader = null }) {
+  const proxy = createProxy(config)
+  const resolveConsumer = createIdentityResolver({ mode, headerName: consumerHeader })
+
+  function serveStatic(res, urlPath) {
+    const rel = urlPath === "/" ? "/index.html" : urlPath
+    const file = path.join(panelDir, path.normalize(rel))
+    if (!file.startsWith(panelDir)) {
+      sendError(res, 403, "forbidden", "forbidden")
+      return
+    }
+    if (!fs.existsSync(file) || !fs.statSync(file).isFile()) {
+      if (rel === "/config.js") {
+        const body = Buffer.from("/* 由 opencode-stats-reporter 托管 */\n")
+        res.writeHead(200, { "content-type": MIME[".js"], "content-length": body.length })
+        res.end(body)
+        return
+      }
+      sendError(res, 404, "not found", "not_found")
+      return
+    }
+    let body = fs.readFileSync(file)
+    const ext = path.extname(file).toLowerCase()
+    if (ext === ".html") body = Buffer.from(injectConfig(body.toString("utf8")), "utf8")
+    res.writeHead(200, { "content-type": MIME[ext] || "application/octet-stream", "content-length": body.length })
+    res.end(body)
+  }
+
+  const server = http.createServer(async (req, res) => {
+    const url = new URL(req.url, "http://localhost")
+    const p = url.pathname
+    try {
+      if (p === "/healthz") {
+        sendJson(res, 200, { object: "health", ok: true, mode })
+        return
+      }
+
+      // 用量类 → 反代到上游网关
+      if (p === "/v1/models" || p.startsWith("/v1/usage/")) {
+        await proxy(req, res, url)
+        return
+      }
+
+      // 会话类 → 本地存储；托管模式需网关注入身份，本地模式归入单一本地用户
+      const isSessionRoute = p === "/v1/session-usage/report" || p === "/v1/sessions" || p.startsWith("/v1/sessions/")
+      if (isSessionRoute) {
+        const consumer = resolveConsumer(req)
+        if (!consumer) {
+          sendError(res, 401, "缺少或非法的消费者身份", "missing_consumer", "authentication_error")
+          return
+        }
+        if (p === "/v1/session-usage/report" && req.method === "POST") {
+          let body
+          try {
+            body = JSON.parse((await readBody(req)).toString("utf8"))
+          } catch (e) {
+            if (e instanceof ApiError) {
+              sendError(res, e.status, e.message, e.code, e.type)
+              return
+            }
+            sendError(res, 400, "请求体不是合法 JSON", "invalid_body")
+            return
+          }
+          sendJson(res, 200, report(store, consumer, body))
+          return
+        }
+        if (p === "/v1/sessions" && req.method === "GET") {
+          sendJson(res, 200, listSessions(store, consumer, url.searchParams))
+          return
+        }
+        if (p === "/v1/sessions/summary" && req.method === "GET") {
+          sendJson(res, 200, sessionsSummary(store, consumer, url.searchParams))
+          return
+        }
+        if (p.startsWith("/v1/sessions/") && req.method === "GET") {
+          const id = decodeURIComponent(p.slice("/v1/sessions/".length))
+          if (!id || id.includes("/")) {
+            sendError(res, 404, "not found", "not_found")
+            return
+          }
+          sendJson(res, 200, sessionDetail(store, consumer, id, url.searchParams))
+          return
+        }
+        sendError(res, 404, "not found", "not_found")
+        return
+      }
+
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        sendError(res, 405, "method not allowed", "method_not_allowed")
+        return
+      }
+      serveStatic(res, p)
+    } catch (err) {
+      if (err instanceof ApiError) {
+        sendError(res, err.status, err.message, err.code, err.type)
+        return
+      }
+      sendError(res, 500, "internal error", "internal", "internal_error")
+      console.error("[error] " + (err && err.stack ? err.stack : err))
+    }
+  })
+
+  return server
+}

package/src/session-api.js

@@ -0,0 +1,97 @@
+import { sanitizeRecord, WINDOWS } from "./store.js"
+
+export const MAX_SESSIONS_PER_REPORT = 200
+export const SUPPORTED_SCHEMA_VERSION = 1
+
+export class ApiError extends Error {
+  constructor(status, message, code, type = "invalid_request_error") {
+    super(message)
+    this.status = status
+    this.code = code
+    this.type = type
+  }
+}
+
+const iso = (ms = Date.now()) => new Date(ms).toISOString()
+
+const boundedInt = (raw, name, dflt, low, high) => {
+  if (raw === undefined || raw === null || raw === "") return dflt
+  const n = Number.parseInt(raw, 10)
+  if (!Number.isFinite(n)) throw new ApiError(400, `${name} 必须是整数`, `invalid_${name}`)
+  if (n < low || n > high) throw new ApiError(400, `${name} 必须在 ${low}..${high} 之间`, `invalid_${name}`)
+  return n
+}
+
+const encodeCursor = (c) => Buffer.from(JSON.stringify(c), "utf8").toString("base64url")
+const decodeCursor = (raw) => {
+  try {
+    const v = JSON.parse(Buffer.from(raw, "base64url").toString("utf8"))
+    return [Number(v[0]), String(v[1])]
+  } catch {
+    throw new ApiError(400, "cursor 非法", "invalid_cursor")
+  }
+}
+
+/** POST /v1/session-usage/report —— 租户由调用方解析好的 consumer 决定，body 内身份字段一律忽略 */
+export function report(store, consumer, body) {
+  if (!body || typeof body !== "object") throw new ApiError(400, "请求体必须是 JSON 对象", "invalid_body")
+  if (body.schema_version !== SUPPORTED_SCHEMA_VERSION) {
+    throw new ApiError(400, `不支持的 schema_version: ${body.schema_version}`, "unsupported_schema")
+  }
+  if (!Array.isArray(body.sessions) || body.sessions.length === 0) {
+    throw new ApiError(400, "sessions 必须是非空数组", "invalid_sessions")
+  }
+  if (body.sessions.length > MAX_SESSIONS_PER_REPORT) {
+    throw new ApiError(400, `单请求会话数超过上限 ${MAX_SESSIONS_PER_REPORT}`, "too_many_sessions")
+  }
+  if (!body.install_id) throw new ApiError(400, "缺少 install_id", "invalid_install_id")
+
+  const installId = String(body.install_id).slice(0, 200)
+  const reporterVersion = body.reporter && body.reporter.version ? String(body.reporter.version).slice(0, 64) : null
+  const records = body.sessions.map((raw) => {
+    const rec = sanitizeRecord(raw)
+    if (!rec) throw new ApiError(400, "会话记录缺少 session_id", "invalid_session_record")
+    rec.install_id = installId // body 级 install_id 为准
+    return rec
+  })
+  const res = store.upsertBatch(consumer, records, {
+    source: "reporter",
+    schemaVersion: SUPPORTED_SCHEMA_VERSION,
+    reporterVersion,
+  })
+  return { object: "report_result", accepted: res.accepted, skipped: res.skipped, server_time: iso(), results: res.results }
+}
+
+/** GET /v1/sessions */
+export function listSessions(store, consumer, params) {
+  const window = params.get("window") || undefined
+  if (window && !WINDOWS.includes(window)) throw new ApiError(400, "window 必须是: today, week, month", "invalid_window")
+  const limit = boundedInt(params.get("limit"), "limit", 50, 1, 200)
+  const cursorRaw = params.get("cursor")
+  const { data, nextCursor } = store.listSessions(consumer, {
+    window,
+    model: params.get("model") || undefined,
+    agent: params.get("agent") || undefined,
+    installId: params.get("install_id") || undefined,
+    limit,
+    cursor: cursorRaw ? decodeCursor(cursorRaw) : null,
+  })
+  return { object: "list", window: window || null, as_of: iso(), data, next_cursor: nextCursor ? encodeCursor(nextCursor) : null }
+}
+
+/** GET /v1/sessions/{id} */
+export function sessionDetail(store, consumer, sessionId, params) {
+  const row = store.getSession(consumer, sessionId, params.get("install_id") || undefined)
+  if (!row) throw new ApiError(404, "not found", "not_found")
+  return { object: "session", data: row }
+}
+
+/** GET /v1/sessions/summary */
+export function sessionsSummary(store, consumer, params) {
+  const window = params.get("window") || undefined
+  if (window && !WINDOWS.includes(window)) throw new ApiError(400, "window 必须是: today, week, month", "invalid_window")
+  const groupBy = params.get("group_by") || "model"
+  const data = store.summary(consumer, { window, groupBy })
+  if (data === undefined) throw new ApiError(400, "group_by 必须是: model, agent, install, day", "invalid_group_by")
+  return { object: "list", window: window || null, group_by: groupBy, as_of: iso(), data }
+}

package/src/store.js

@@ -0,0 +1,246 @@
+import fs from "node:fs"
+import path from "node:path"
+import { DatabaseSync } from "node:sqlite"
+
+export const LOCAL_CONSUMER = "local"
+export const WINDOWS = ["today", "week", "month"]
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS session_usage (
+  consumer_id           TEXT    NOT NULL,
+  install_id            TEXT    NOT NULL,
+  session_id            TEXT    NOT NULL,
+  source                TEXT    NOT NULL DEFAULT 'reporter',
+  schema_version        INTEGER NOT NULL DEFAULT 1,
+  reporter_version      TEXT,
+  client_session_header TEXT,
+  model                 TEXT,
+  agent                 TEXT,
+  tokens_input          INTEGER NOT NULL DEFAULT 0,
+  tokens_output         INTEGER NOT NULL DEFAULT 0,
+  tokens_reasoning      INTEGER NOT NULL DEFAULT 0,
+  tokens_cache_read     INTEGER NOT NULL DEFAULT 0,
+  tokens_cache_write    INTEGER NOT NULL DEFAULT 0,
+  cost                  REAL,
+  message_count         INTEGER NOT NULL DEFAULT 0,
+  revision              INTEGER NOT NULL DEFAULT 0,
+  session_created_at    INTEGER,
+  last_activity_at      INTEGER NOT NULL DEFAULT 0,
+  client_reported_at    INTEGER,
+  first_seen_at         INTEGER NOT NULL,
+  last_reported_at      INTEGER NOT NULL,
+  PRIMARY KEY (consumer_id, install_id, session_id)
+);
+CREATE INDEX IF NOT EXISTS idx_su_consumer_activity ON session_usage(consumer_id, last_activity_at DESC);
+CREATE INDEX IF NOT EXISTS idx_su_consumer_model    ON session_usage(consumer_id, model);
+CREATE INDEX IF NOT EXISTS idx_su_consumer_session  ON session_usage(consumer_id, session_id);
+`
+
+const nowMs = () => Date.now()
+
+/** UTC+8 日历对齐窗口起点（毫秒）；未知窗口返回 null */
+export function windowStartMs(window) {
+  if (!WINDOWS.includes(window)) return null
+  const d = new Date(Date.now() + 8 * 3600 * 1000) // 平移到 UTC+8 墙钟
+  let startUtc8
+  if (window === "today") {
+    startUtc8 = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())
+  } else if (window === "week") {
+    const wd = (d.getUTCDay() + 6) % 7 // 周一=0
+    startUtc8 = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() - wd)
+  } else {
+    startUtc8 = Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), 1)
+  }
+  return startUtc8 - 8 * 3600 * 1000
+}
+
+const int = (v, dflt = 0) => {
+  const n = Number.parseInt(v, 10)
+  return Number.isFinite(n) && n >= 0 ? n : dflt
+}
+const optInt = (v) => (v === undefined || v === null || v === "" ? null : int(v, 0))
+const optNum = (v) => {
+  if (v === undefined || v === null || v === "") return null
+  const n = Number(v)
+  return Number.isFinite(n) ? n : null
+}
+const str = (v, max = 200) => (v === undefined || v === null ? null : String(v).slice(0, max))
+
+/** 字段白名单：任何身份字段都在此被丢弃 */
+export function sanitizeRecord(raw) {
+  if (!raw || typeof raw !== "object") return null
+  const sessionId = str(raw.session_id)
+  // install_id 以 body 级为准（见 session-api.report），记录级可缺省
+  if (!sessionId) return null
+  return {
+    session_id: sessionId,
+    install_id: str(raw.install_id),
+    model: str(raw.model),
+    agent: str(raw.agent),
+    tokens_input: int(raw.tokens_input),
+    tokens_output: int(raw.tokens_output),
+    tokens_reasoning: int(raw.tokens_reasoning),
+    tokens_cache_read: int(raw.tokens_cache_read),
+    tokens_cache_write: int(raw.tokens_cache_write),
+    cost: optNum(raw.cost),
+    message_count: int(raw.message_count),
+    revision: int(raw.revision),
+    session_created_at: optInt(raw.session_created_at),
+    last_activity_at: int(raw.last_activity_at),
+    client_reported_at: optInt(raw.client_reported_at),
+    client_session_header: str(raw.client_session_header),
+  }
+}
+
+function withDerived(row) {
+  const out = { ...row }
+  out.tokens_input_total = row.tokens_input + row.tokens_cache_read + row.tokens_cache_write
+  out.tokens_output_total = row.tokens_output + row.tokens_reasoning
+  return out
+}
+
+export class Store {
+  constructor(dbPath) {
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true })
+    this.db = new DatabaseSync(dbPath)
+    this.db.exec("PRAGMA journal_mode=WAL")
+    this.db.exec("PRAGMA busy_timeout=3000")
+  }
+
+  migrate() {
+    this.db.exec(SCHEMA)
+  }
+
+  indexes() {
+    return this.db
+      .prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name='session_usage'")
+      .all()
+      .map((r) => r.name)
+  }
+
+  close() {
+    this.db.close()
+  }
+
+  upsertBatch(consumerId, records, { source = "reporter", schemaVersion = 1, reporterVersion = null } = {}) {
+    const ts = nowMs()
+    const results = []
+    let accepted = 0
+    let skipped = 0
+    const find = this.db.prepare(
+      "SELECT revision, last_activity_at FROM session_usage WHERE consumer_id=? AND install_id=? AND session_id=?",
+    )
+    const insert = this.db.prepare(`INSERT INTO session_usage
+      (consumer_id, install_id, session_id, source, schema_version, reporter_version, client_session_header,
+       model, agent, tokens_input, tokens_output, tokens_reasoning, tokens_cache_read, tokens_cache_write,
+       cost, message_count, revision, session_created_at, last_activity_at, client_reported_at,
+       first_seen_at, last_reported_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`)
+    const update = this.db.prepare(`UPDATE session_usage SET
+      source=?, schema_version=?, reporter_version=?, client_session_header=?, model=?, agent=?,
+      tokens_input=?, tokens_output=?, tokens_reasoning=?, tokens_cache_read=?, tokens_cache_write=?,
+      cost=?, message_count=?, revision=?, session_created_at=?, last_activity_at=?, client_reported_at=?,
+      last_reported_at=?
+      WHERE consumer_id=? AND install_id=? AND session_id=?`)
+
+    for (const r of records) {
+      const prev = find.get(consumerId, r.install_id, r.session_id)
+      let status
+      if (!prev) {
+        status = "upserted"
+        insert.run(
+          consumerId, r.install_id, r.session_id, source, schemaVersion, reporterVersion, r.client_session_header,
+          r.model, r.agent, r.tokens_input, r.tokens_output, r.tokens_reasoning, r.tokens_cache_read, r.tokens_cache_write,
+          r.cost, r.message_count, r.revision, r.session_created_at, r.last_activity_at, r.client_reported_at, ts, ts,
+        )
+      } else if (r.revision > prev.revision || (r.revision === prev.revision && r.last_activity_at > prev.last_activity_at)) {
+        status = "upserted"
+        update.run(
+          source, schemaVersion, reporterVersion, r.client_session_header, r.model, r.agent,
+          r.tokens_input, r.tokens_output, r.tokens_reasoning, r.tokens_cache_read, r.tokens_cache_write,
+          r.cost, r.message_count, r.revision, r.session_created_at, r.last_activity_at, r.client_reported_at, ts,
+          consumerId, r.install_id, r.session_id,
+        )
+      } else if (r.revision === prev.revision && r.last_activity_at === prev.last_activity_at) {
+        status = "unchanged"
+      } else {
+        status = "stale"
+      }
+      if (status === "upserted" || status === "unchanged") accepted += 1
+      else skipped += 1
+      results.push({ session_id: r.session_id, install_id: r.install_id, status })
+    }
+    return { accepted, skipped, results }
+  }
+
+  listSessions(consumerId, { window, model, agent, installId, limit = 50, cursor = null } = {}) {
+    const where = ["consumer_id=?"]
+    const args = [consumerId]
+    const start = windowStartMs(window)
+    if (start !== null) {
+      where.push("last_activity_at>=?")
+      args.push(start)
+    }
+    if (model) {
+      where.push("model=?")
+      args.push(model)
+    }
+    if (agent) {
+      where.push("agent=?")
+      args.push(agent)
+    }
+    if (installId) {
+      where.push("install_id=?")
+      args.push(installId)
+    }
+    if (cursor) {
+      where.push("(last_activity_at < ? OR (last_activity_at = ? AND session_id < ?))")
+      args.push(cursor[0], cursor[0], cursor[1])
+    }
+    const sql = `SELECT * FROM session_usage WHERE ${where.join(" AND ")} ORDER BY last_activity_at DESC, session_id DESC LIMIT ?`
+    const rows = this.db.prepare(sql).all(...args, limit + 1)
+    const hasNext = rows.length > limit
+    const data = rows.slice(0, limit).map(withDerived)
+    const nextCursor = hasNext && data.length ? [data[data.length - 1].last_activity_at, data[data.length - 1].session_id] : null
+    return { data, nextCursor }
+  }
+
+  getSession(consumerId, sessionId, installId) {
+    const where = ["consumer_id=?", "session_id=?"]
+    const args = [consumerId, sessionId]
+    if (installId) {
+      where.push("install_id=?")
+      args.push(installId)
+    }
+    const row = this.db.prepare(`SELECT * FROM session_usage WHERE ${where.join(" AND ")} LIMIT 1`).get(...args)
+    return row ? withDerived(row) : null
+  }
+
+  summary(consumerId, { window, groupBy = "model" } = {}) {
+    const keyExpr = {
+      model: "model",
+      agent: "agent",
+      install: "install_id",
+      day: "strftime('%Y-%m-%d', last_activity_at/1000, 'unixepoch', '+8 hours')",
+    }[groupBy]
+    if (!keyExpr) return undefined
+    const where = ["consumer_id=?"]
+    const args = [consumerId]
+    const start = windowStartMs(window)
+    if (start !== null) {
+      where.push("last_activity_at>=?")
+      args.push(start)
+    }
+    const sql = `SELECT ${keyExpr} AS key, COUNT(*) AS sessions,
+      SUM(tokens_input) AS tokens_input, SUM(tokens_output) AS tokens_output, SUM(tokens_reasoning) AS tokens_reasoning,
+      SUM(tokens_cache_read) AS tokens_cache_read, SUM(tokens_cache_write) AS tokens_cache_write
+      FROM session_usage WHERE ${where.join(" AND ")} GROUP BY key
+      ORDER BY SUM(tokens_input)+SUM(tokens_output)+SUM(tokens_reasoning) DESC`
+    return this.db.prepare(sql).all(...args).map((r) => {
+      const out = { ...r }
+      out.tokens_input_total = out.tokens_input + out.tokens_cache_read + out.tokens_cache_write
+      out.tokens_output_total = out.tokens_output + out.tokens_reasoning
+      return out
+    })
+  }
+}