dsh-spendingframe 0.0.0-stage → 0.2.2

package/lib/index.js

@@ -0,0 +1,165 @@
+/**
+ * DSHBalance 宿主半（包名 dsh-spendingframe）：把「高峰/空闲 + 会话花费 + 今日花费」暴露成一个只读 HTTP 路由。
+ *
+ * 客户端半（client/client.js）只负责显示：它每 5 分钟拉一次
+ * `GET /dsh-spendingframe/summary?session=<会话 id>`，因此金额只在宿主算一次，
+ * 浏览器不需要接触会话日志，也不需要自己维护价目表。
+ *
+ * 路由注册在裸 webServer 上（exact 匹配优先于宿主自己的 `/api` 前缀），
+ * 所以自己判断来源：只接受回环地址（或宿主声明的可信 authority）与同源页面，
+ * 拒绝 DNS rebinding 页面与跨站请求。接口是只读的，不写入任何状态。
+ */
+
+import { buildSummary } from './summary.js'
+
+export const name = 'dsh-spendingframe'
+
+const ROUTE = '/dsh-spendingframe/summary'
+
+export function apply(ctx) {
+  // webServer 只在网页宿主里存在；没有它的组合（headless / acp 等）安静地不挂载。
+  ctx.inject(['webServer'], (hostCtx) => {
+    hostCtx.effect(() => {
+      const dispose = hostCtx.webServer.register({
+        kind: 'exact',
+        path: ROUTE,
+        handler: (request, response) => { void handle(hostCtx, request, response) },
+      })
+      return () => { dispose() }
+    }, 'dsh-spendingframe: /dsh-spendingframe/summary')
+  })
+}
+
+async function handle(ctx, request, response) {
+  if (refuseUntrusted(ctx, request, response)) return
+
+  const method = request.method ?? 'GET'
+  if (method !== 'GET' && method !== 'HEAD') {
+    sendJson(response, 405, { ok: false, error: '只支持 GET' })
+    return
+  }
+
+  let sessionId = ''
+  try {
+    sessionId = new URL(request.url ?? '/', 'http://dsh.local').searchParams.get('session') ?? ''
+  } catch {
+    sessionId = ''
+  }
+
+  try {
+    sendJson(response, 200, buildSummary({ sessionId }))
+  } catch (error) {
+    sendJson(response, 500, { ok: false, error: error instanceof Error ? error.message : String(error) })
+  }
+}
+
+/**
+ * 来源闸门。
+ *
+ * 首选宿主自己的登录门禁（Host Connection 的 `requestRejection`）：它同时做
+ * Host/Origin 围栏与浏览器 cookie 校验，网页里的请求本来就带着它签发的 cookie
+ * （宿主自己的 `/api` 也靠这一套），所以面板能读到数据，而本机其它未登录客户端
+ * 会被 401 拒绝。
+ *
+ * 该服务在宿主启动早期可能还没就绪（dsh-market 就因为启动时取不到它而永久退化成
+ * 无门禁），所以这里在**请求时**才查一次；确实没有这个服务时才退回到自己实现的
+ * authority 围栏：只接受回环地址、宿主声明的可信 authority，以及同源页面。
+ */
+function refuseUntrusted(ctx, request, response) {
+  const connection = typeof ctx.get === 'function' ? ctx.get('connection') : undefined
+  const gate = connection?.requestRejection
+  if (typeof gate === 'function') {
+    let status
+    try {
+      status = gate.call(connection, request)
+    } catch {
+      status = 403 // 门禁抛错不等于放行
+    }
+    if (typeof status === 'number') {
+      sendJson(response, status, {
+        ok: false,
+        error: status === 401 ? '需要先登录 DSH：请重新打开 dsh web 启动时打印的网址' : '请求来源不受信任，已拒绝',
+      })
+      return true
+    }
+    return false
+  }
+  return refuseByAuthority(ctx, request, response)
+}
+
+/**
+ * 没有登录门禁时的兜底：回环地址 / 声明 authority / 同源页面。
+ *
+ * 要点是 `Host` 是页面无法伪造的头，所以 DNS rebinding（Origin 与 Host 都被换成
+ * 攻击者的域名）会在这里被拒；桌面端转发代理会剥掉 host/origin，因此“头不存在”
+ * 按放行处理——这与 dsh-market 的 sameOrigin 是同一套判断。
+ */
+function refuseByAuthority(ctx, request, response) {
+  const host = request.headers.host
+  if (request.headers['sec-fetch-site'] === 'cross-site') {
+    sendJson(response, 403, { ok: false, error: '跨站请求已拒绝' })
+    return true
+  }
+  if (typeof host === 'string' && host !== '' && !loopbackAuthority(host) && !trustedAuthority(host, trustedHosts(ctx))) {
+    sendJson(response, 403, { ok: false, error: '请求来源不受信任，已拒绝' })
+    return true
+  }
+  const origin = request.headers.origin
+  if (origin !== undefined) {
+    let sameHost = false
+    try {
+      sameHost = host === undefined || new URL(origin).host === host
+    } catch {
+      sameHost = false // 存在但无法解析（含 Origin: null）不算同源
+    }
+    if (!sameHost) {
+      sendJson(response, 403, { ok: false, error: '跨站请求已拒绝' })
+      return true
+    }
+  }
+  return false
+}
+
+/** 宿主声明的额外 authority（`dsh web --trusted-host <name>`）；服务缺席时为空。 */
+function trustedHosts(ctx) {
+  const connection = typeof ctx.get === 'function' ? ctx.get('connection') : undefined
+  const declared = connection?.trustedHosts
+  return Array.isArray(declared) ? declared.filter((entry) => typeof entry === 'string') : []
+}
+
+/** `127.0.0.1` / `localhost` / `[::1]`（含端口）视为回环。 */
+function loopbackAuthority(host) {
+  const lower = host.toLowerCase()
+  const name = lower.startsWith('[') ? lower.slice(0, lower.indexOf(']') + 1) : lower.split(':')[0]
+  return name === '127.0.0.1' || name === 'localhost' || name === '[::1]'
+}
+
+/** `host` 是否命中某条声明：带端口按完整 authority 比较，不带端口只比主机名。 */
+function trustedAuthority(host, declared) {
+  const actual = parseAuthority(host)
+  if (actual === null) return false
+  return declared.some((entry) => {
+    const expected = parseAuthority(entry)
+    if (expected === null) return false
+    return expected.port === '' ? expected.hostname === actual.hostname : expected.host === actual.host
+  })
+}
+
+/** 解析 `host[:port]`；必须原样往返，避免把 `evil.com/path` 当成合法声明。 */
+function parseAuthority(value) {
+  try {
+    const url = new URL(`http://${value}`)
+    const canonical = url.port === '' ? url.hostname : `${url.hostname}:${url.port}`
+    return canonical === value.toLowerCase() ? url : null
+  } catch {
+    return null
+  }
+}
+
+function sendJson(response, status, payload) {
+  response.writeHead(status, {
+    'cache-control': 'no-store',
+    'content-type': 'application/json; charset=utf-8',
+  })
+  response.end(JSON.stringify(payload))
+}

package/lib/pricing.js

@@ -0,0 +1,184 @@
+/**
+ * DeepSeek API 分时定价与人民币费用计算。
+ *
+ * 高峰时段：北京时间周一至周五（不含中国法定节假日）09:00–12:00、14:00–18:00。
+ * 其余时段（含周末与中国法定节假日全天）为空闲时段。
+ *
+ * 这里全是纯函数，不依赖 DSH 运行时，便于单独测试。
+ */
+
+/** 北京时间相对 UTC 的固定偏移（中国不使用夏令时）。 */
+const BEIJING_OFFSET_MS = 8 * 60 * 60 * 1000
+
+/** 高峰时段区间，单位：北京时间当天第几分钟。 */
+const PEAK_WINDOWS = [
+  [9 * 60, 12 * 60],
+  [14 * 60, 18 * 60],
+]
+
+/**
+ * 中国法定节假日（国务院办公厅通知）。
+ *
+ * 只列放假日期：调休上班的周末按规则仍属空闲时段，无需单独处理。
+ * 未知年份只按“工作日 + 时段”判定，不会把普通工作日误判成节假日。
+ *
+ * 数据来源：
+ * 2024 — 国办发明电〔2023〕7 号
+ * 2025 — 国办发明电〔2024〕12 号
+ * 2026 — 国办发明电〔2025〕7 号
+ */
+const HOLIDAY_RANGES = [
+  // 2024
+  ['2024-01-01', '2024-01-01'], // 元旦
+  ['2024-02-10', '2024-02-17'], // 春节
+  ['2024-04-04', '2024-04-06'], // 清明节
+  ['2024-05-01', '2024-05-05'], // 劳动节
+  ['2024-06-08', '2024-06-10'], // 端午节
+  ['2024-09-15', '2024-09-17'], // 中秋节
+  ['2024-10-01', '2024-10-07'], // 国庆节
+  // 2025
+  ['2025-01-01', '2025-01-01'], // 元旦
+  ['2025-01-28', '2025-02-04'], // 春节
+  ['2025-04-04', '2025-04-06'], // 清明节
+  ['2025-05-01', '2025-05-05'], // 劳动节
+  ['2025-05-31', '2025-06-02'], // 端午节
+  ['2025-10-01', '2025-10-08'], // 国庆节、中秋节
+  // 2026
+  ['2026-01-01', '2026-01-03'], // 元旦
+  ['2026-02-15', '2026-02-23'], // 春节
+  ['2026-04-04', '2026-04-06'], // 清明节
+  ['2026-05-01', '2026-05-05'], // 劳动节
+  ['2026-06-19', '2026-06-21'], // 端午节
+  ['2026-09-25', '2026-09-27'], // 中秋节
+  ['2026-10-01', '2026-10-07'], // 国庆节
+]
+
+/** 展开成 `YYYY-MM-DD` 集合，按北京时间的日期字符串直接查表。 */
+function expandHolidays(ranges) {
+  const days = new Set()
+  for (const [from, to] of ranges) {
+    const cursor = new Date(`${from}T00:00:00Z`)
+    const end = new Date(`${to}T00:00:00Z`)
+    while (cursor.getTime() <= end.getTime()) {
+      days.add(cursor.toISOString().slice(0, 10))
+      cursor.setUTCDate(cursor.getUTCDate() + 1)
+    }
+  }
+  return days
+}
+
+const HOLIDAYS = expandHolidays(HOLIDAY_RANGES)
+
+/**
+ * 把时间戳拆成北京时间字段。
+ *
+ * 用固定 +8 偏移后再读 UTC 字段：不依赖宿主机的本地时区设置，
+ * 结果在任何机器上都一致。
+ */
+export function beijingParts(timeMs) {
+  const shifted = new Date((Number.isFinite(timeMs) ? timeMs : Date.now()) + BEIJING_OFFSET_MS)
+  return {
+    ymd: shifted.toISOString().slice(0, 10),
+    weekday: shifted.getUTCDay(), // 0 = 周日
+    minutes: shifted.getUTCHours() * 60 + shifted.getUTCMinutes(),
+  }
+}
+
+/** 该日期是否为（北京时间的）中国法定节假日。 */
+export function isHoliday(ymd) {
+  return HOLIDAYS.has(ymd)
+}
+
+/** 某个时刻是否处于高峰时段。 */
+export function isPeak(timeMs) {
+  const { ymd, weekday, minutes } = beijingParts(timeMs)
+  if (weekday === 0 || weekday === 6) return false
+  if (HOLIDAYS.has(ymd)) return false
+  return PEAK_WINDOWS.some(([from, to]) => minutes >= from && minutes < to)
+}
+
+/** 距离下一次高峰/空闲切换的毫秒数（用于提示，不参与计费）。 */
+export function msUntilNextChange(timeMs) {
+  const now = Number.isFinite(timeMs) ? timeMs : Date.now()
+  const current = isPeak(now)
+  // 北京时间的整点候选：每天的 00:00、09:00、12:00、14:00、18:00。
+  for (let day = 0; day <= 9; day++) {
+    const dayStart = beijingDayStart(now) + day * 24 * 60 * 60 * 1000
+    for (const minutes of [0, 9 * 60, 12 * 60, 14 * 60, 18 * 60]) {
+      const candidate = dayStart + minutes * 60 * 1000
+      if (candidate <= now) continue
+      if (isPeak(candidate) !== current) return candidate - now
+    }
+  }
+  return null
+}
+
+/** 北京时间当天 00:00 的时间戳。 */
+export function beijingDayStart(timeMs) {
+  const now = Number.isFinite(timeMs) ? timeMs : Date.now()
+  const shifted = new Date(now + BEIJING_OFFSET_MS)
+  const midnight = Date.UTC(shifted.getUTCFullYear(), shifted.getUTCMonth(), shifted.getUTCDate())
+  return midnight - BEIJING_OFFSET_MS
+}
+
+/**
+ * 官方单价，单位：元 / 百万 tokens。
+ *
+ * 每个模型给出缓存命中输入、缓存未命中输入与输出三档；
+ * 每档再分空闲（offPeak）与高峰（peak）。
+ */
+export const PRICES = {
+  'deepseek-flash': {
+    hit: { offPeak: 0.02, peak: 0.04 },
+    miss: { offPeak: 1, peak: 2 },
+    out: { offPeak: 4, peak: 8 },
+  },
+  'deepseek-v4-pro': {
+    hit: { offPeak: 0.15, peak: 0.3 },
+    miss: { offPeak: 4.5, peak: 9 },
+    out: { offPeak: 13.5, peak: 27 },
+  },
+}
+
+/**
+ * 选择模型价目表。
+ *
+ * 精确命中优先；名称里带 `pro` / `flash` 的变体按对应档位计价；
+ * 其余未知模型退回 flash 价目，并由调用方在响应里说明，避免静默出错。
+ */
+export function priceTableFor(modelId) {
+  const id = String(modelId ?? '').trim().toLowerCase()
+  if (Object.hasOwn(PRICES, id)) return { table: PRICES[id], assumed: false }
+  if (id.includes('pro')) return { table: PRICES['deepseek-v4-pro'], assumed: true }
+  if (id.includes('flash')) return { table: PRICES['deepseek-flash'], assumed: true }
+  return { table: PRICES['deepseek-flash'], assumed: true }
+}
+
+/**
+ * 一次调用的费用（元）。
+ *
+ * @param usage - `inputTokens` 为缓存未命中的输入 tokens，`cacheReadTokens` 为命中，
+ *   这是 DSH 会话日志里 `assistant/message.data.usage` 的实际含义。
+ * @param table - {@link priceTableFor} 选出的价目表。
+ * @param peak - 这次调用发生的时刻是否处于高峰时段。
+ */
+export function costOfUsage(usage, table, peak) {
+  if (usage === null || typeof usage !== 'object') return 0
+  const tier = peak ? 'peak' : 'offPeak'
+  const hit = numberOrZero(usage.cacheReadTokens)
+  const miss = numberOrZero(usage.inputTokens)
+  const out = numberOrZero(usage.outputTokens)
+  return (hit * table.hit[tier] + miss * table.miss[tier] + out * table.out[tier]) / 1e6
+}
+
+/** 仅接受有限非负数，日志里的脏字段按 0 计。 */
+function numberOrZero(value) {
+  return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0
+}
+
+/** 当前时段的中文名，用于提示文案。 */
+export function windowLabel(peak) {
+  return peak ? '高峰时段' : '空闲时段'
+}
+
+export { PEAK_WINDOWS, HOLIDAYS }

package/lib/session-logs.js

@@ -0,0 +1,197 @@
+/**
+ * 读取 DSH 会话日志里的 token 用量。
+ *
+ * 会话日志位于 `<DSH_HOME>/sessions/<工作区>/<会话 id>/session.v4.jsonl.zstd`：
+ * 追加写入的 zstd 多帧文件，每帧一到多行 JSON 记录。带用量的是
+ * `assistant/message`，其 `data.usage` 为
+ * `{ inputTokens(缓存未命中), cacheReadTokens(缓存命中), outputTokens, ... }`，
+ * 模型在 `data.message.source.model`。
+ *
+ * 这里只做两件事：把文件读成用量记录，并缓存解析结果（按 mtime + size 失效），
+ * 这样每 5 分钟一次的轮询不会反复解压没变过的历史会话。
+ */
+
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { zstdDecompressSync } from 'node:zlib'
+
+const ZSTD_MAGIC = [0x28, 0xb5, 0x2f, 0xfd]
+const LOG_SUFFIX = '.jsonl.zstd'
+const LOG_PREFIX = 'session.v'
+
+/** 解析 DSH home：显式配置 > `DSH_HOME` > `~/.dsh`。 */
+export function resolveDshHome(configured, env = process.env) {
+  const fromEnv = env?.DSH_HOME
+  const selected = typeof configured === 'string' && configured.trim() !== ''
+    ? configured.trim()
+    : typeof fromEnv === 'string' && fromEnv.trim() !== ''
+      ? fromEnv.trim()
+      : join(homedir(), '.dsh')
+  const expanded = selected === '~' ? homedir() : selected.startsWith('~/') || selected.startsWith('~\\') ? join(homedir(), selected.slice(2)) : selected
+  return resolve(expanded)
+}
+
+/**
+ * 列出全部会话日志文件。
+ *
+ * 目录层级由 DSH 决定，这里只认形状：任意两层目录下的 `session.v*.jsonl.zstd`。
+ * 找不到（例如全新安装还没有会话）不是错误，返回空数组。
+ */
+export function listSessionLogs(home) {
+  const root = join(home, 'sessions')
+  const found = []
+  let workspaces = []
+  try {
+    workspaces = readdirSync(root, { withFileTypes: true })
+  } catch {
+    return found
+  }
+  for (const workspace of workspaces) {
+    if (!workspace.isDirectory()) continue
+    const workspaceDir = join(root, workspace.name)
+    let sessions = []
+    try {
+      sessions = readdirSync(workspaceDir, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const session of sessions) {
+      if (!session.isDirectory()) continue
+      const sessionDir = join(workspaceDir, session.name)
+      let entries = []
+      try {
+        entries = readdirSync(sessionDir, { withFileTypes: true })
+      } catch {
+        continue
+      }
+      for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.startsWith(LOG_PREFIX) || !entry.name.endsWith(LOG_SUFFIX)) continue
+        found.push({ path: join(sessionDir, entry.name), sessionId: session.name })
+      }
+    }
+  }
+  return found
+}
+
+/** 把追加写入的多帧 zstd 文件解成一整段文本；写坏的尾部帧直接放弃。 */
+export function decodeLogFile(path) {
+  const buffer = readFileSync(path)
+  const offsets = []
+  for (let i = 0; i + 4 <= buffer.length; i++) {
+    if (buffer[i] === ZSTD_MAGIC[0] && buffer[i + 1] === ZSTD_MAGIC[1] && buffer[i + 2] === ZSTD_MAGIC[2] && buffer[i + 3] === ZSTD_MAGIC[3]) {
+      offsets.push(i)
+    }
+  }
+  const parts = []
+  for (let i = 0; i < offsets.length; i++) {
+    const end = i + 1 < offsets.length ? offsets[i + 1] : buffer.length
+    try {
+      parts.push(zstdDecompressSync(buffer.subarray(offsets[i], end)))
+    } catch {
+      // 最后一个帧可能正在被写入，或历史的坏帧：跳过而不是丢掉整个会话。
+    }
+  }
+  return Buffer.concat(parts).toString('utf8')
+}
+
+/**
+ * 解析一个会话日志中的用量记录。
+ *
+ * 返回 `{ createdAt, parentSession, origin, delegationDepth, records }`：
+ * 会话头（`type: "session"`）里的血缘字段用来把子智能体会话挂回父会话，
+ * `createdAt` 用来排除可能的继承记录。
+ *
+ * 子智能体会话的头部长这样（本机实测）：
+ *   {"type":"session","id":"150f49a5-…","parentSession":"session-79fa1914-…",
+ *    "origin":"subagent","delegationDepth":1,"createdAt":…}
+ * 普通会话没有 `parentSession`，`delegationDepth` 为 0；分支（fork）出来的会话
+ * 同样是 0，因此只有 `origin === "subagent"` 或 `delegationDepth > 0` 才算子智能体。
+ */
+export function parseSessionLog(path) {
+  const text = decodeLogFile(path)
+  let header = null
+  const records = []
+  for (const line of text.split('\n')) {
+    if (line.trim() === '') continue
+    let record
+    try {
+      record = JSON.parse(line)
+    } catch {
+      continue // 追加写入时被截断的最后一行
+    }
+    if (record.type === 'session') {
+      if (header === null) header = record
+      continue
+    }
+    if (record.type !== 'assistant/message') continue
+    const usage = record.data?.usage
+    if (usage === null || typeof usage !== 'object') continue
+    records.push({
+      time: typeof record.time === 'number' ? record.time : null,
+      model: typeof record.data?.message?.source?.model === 'string' ? record.data.message.source.model : '',
+      usage,
+    })
+  }
+  return {
+    createdAt: typeof header?.createdAt === 'number' ? header.createdAt : null,
+    parentSession: typeof header?.parentSession === 'string' && header.parentSession !== '' ? header.parentSession : null,
+    origin: typeof header?.origin === 'string' ? header.origin : null,
+    delegationDepth: typeof header?.delegationDepth === 'number' ? header.delegationDepth : 0,
+    records,
+  }
+}
+
+/** 已解析会话的缓存，键为文件路径。 */
+const cache = new Map()
+const MAX_CACHED_SESSIONS = 400
+
+/** 读取（必要时重新解析）一个会话，命中缓存时不做任何解压。 */
+export function readSessionLog(file) {
+  const stat = statSync(file.path)
+  const cached = cache.get(file.path)
+  if (cached !== undefined && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
+    return cached.session
+  }
+  const parsed = parseSessionLog(file.path)
+  const session = {
+    sessionId: file.sessionId,
+    path: file.path,
+    createdAt: parsed.createdAt,
+    parentSession: parsed.parentSession,
+    origin: parsed.origin,
+    delegationDepth: parsed.delegationDepth,
+    records: parsed.records,
+  }
+  cache.set(file.path, { size: stat.size, mtimeMs: stat.mtimeMs, session })
+  if (cache.size > MAX_CACHED_SESSIONS) {
+    // Map 保持插入顺序：丢掉最早写入的条目，避免长期运行时无上限增长。
+    const oldest = cache.keys().next()
+    if (!oldest.done) cache.delete(oldest.value)
+  }
+  return session
+}
+
+/**
+ * 读出所有会话的用量记录。
+ *
+ * 单个会话失败只记录在 `errors` 里，不影响其它会话与整体响应。
+ */
+export function collectSessions(home) {
+  const files = listSessionLogs(home)
+  const sessions = []
+  const errors = []
+  for (const file of files) {
+    try {
+      sessions.push(readSessionLog(file))
+    } catch (error) {
+      errors.push({ path: file.path, message: error instanceof Error ? error.message : String(error) })
+    }
+  }
+  return { sessions, errors, fileCount: files.length }
+}
+
+/** 清空缓存（测试与诊断用）。 */
+export function clearSessionCache() {
+  cache.clear()
+}