benchgo-plugin 0.0.0-stage → 0.0.2

package/src/updates.mjs

@@ -0,0 +1,156 @@
+import { readFile, writeFile, mkdir, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { DEFAULT_UPDATE_CONFIG, normalizeUpdateConfig, fetchVerifiedRelease, fetchUpdateBytes, verifyArtifact, isEngineCompatible, isNewerVersion, resolveUpdateUrl } from '../shared/update-feed.mjs';
+import { prepareRelease, activateRelease, getInstallState, rollbackRelease } from '../shared/plugin-install.mjs';
+import { assertSameOrigin } from '../voice/src/web.mjs';
+import { readLimited } from '../voice/src/media.mjs';
+
+const json = async path => JSON.parse(await readFile(path, 'utf8'));
+const conflict = message => Object.assign(new Error(message), { status: 409 });
+
+/** Read the immutable application's version, never the independently updated plugin version. */
+export async function desktopApplicationVersion(executable = process.execPath, readJson = json) {
+  try {
+    const app = await readJson(join(dirname(executable), 'resources', 'app.asar', 'package.json'));
+    if (app.name === 'benchgo-desktop' && typeof app.version === 'string') {
+      isNewerVersion(app.version, app.version);
+      return app.version;
+    }
+  } catch {}
+  return undefined;
+}
+
+/** Each immutable release is staged before one profile manifest switch; loaded code stays intact. */
+export async function createUpdates({ directory, profile, runtime, version, engineVersion, appVersion, isBusy = () => false,
+  installation = 'desktop', fetcher = globalThis.fetch, publicKey, install = { prepareRelease, activateRelease, getInstallState, rollbackRelease } }) {
+  const configFile = join(directory, 'updates.json');
+  const lifetime = new AbortController();
+  const updateFetch = (url, options = {}) => fetcher(url, { ...options, signal: AbortSignal.any([lifetime.signal, ...(options.signal ? [options.signal] : [])]) });
+  let config = { ...DEFAULT_UPDATE_CONFIG }, phase = 'idle', release = null, error = '', checkedAt = null, task = null, lastAction = null, closed = false;
+  try { config = normalizeUpdateConfig(await json(configFile)); } catch (failure) { if (failure.code !== 'ENOENT') error = '更新源配置读取失败，请重新选择更新来源'; }
+  const installed = async () => profile ? await install.getInstallState(profile) : { managed: false };
+  const status = async () => {
+    const state = await installed(), busy = !!(await isBusy());
+    const restartRequired = !!state.managed && state.version !== version;
+    const compatible = !!release && !!engineVersion && isEngineCompatible(engineVersion, release.engine);
+    // A source-deployed host has no desktop application to compare. Unknown is
+    // not an older version, including desktop profiles without app metadata.
+    const currentApp = installation === 'desktop' ? appVersion ?? state.appVersion : undefined;
+    return {
+      // A check can publish its release before the task's finalizer releases admission.
+      // Keep that intermediate response active so clients continue polling readiness.
+      phase: restartRequired ? 'ready' : task && phase === 'idle' ? 'checking' : phase, lastAction, installation, notice: phase === 'unpublished' ? '更新通道尚未就绪' : '', config, current: { plugin: version, engine: engineVersion, app: currentApp },
+      managed: !!state.managed, busy, restartRequired, checkedAt, error,
+      canInstall: !!state.managed && !busy && !restartRequired && !task && compatible && isNewerVersion(release.plugin.version, version),
+      canRollback: !!state.managed && !!state.previous && !restartRequired && !task,
+      release: release ? { ...release, plugin: { ...release.plugin, available: !restartRequired && isNewerVersion(release.plugin.version, version), compatible, reason: compatible ? undefined : '请先升级应用，以匹配此插件需要的引擎。' },
+        ...(release.app ? { app: { ...release.app, available: !!currentApp && isNewerVersion(release.app.version, currentApp), url: resolveUpdateUrl(release.app.url, config) } } : {}) } : null,
+    };
+  };
+  const start = (action, work) => {
+    lastAction = action;
+    error = '';
+    task = Promise.resolve().then(work).catch(failure => {
+      if (failure.code === 'UPDATE_UNPUBLISHED') { release = null; error = ''; phase = 'unpublished'; }
+      else { error = failure.message; phase = 'error'; }
+    }).finally(() => { task = null; });
+  };
+  const guard = async () => {
+    if (closed) throw conflict('更新服务已关闭');
+    if (task) throw conflict('更新正在进行，请稍候');
+    const state = await installed();
+    if (!state.managed) throw conflict(installation === 'server' ? '此主机由服务器部署管理，请由维护者更新' : '此安装需要先升级一次应用，才能独立更新插件');
+    if (state.version !== version) throw conflict('请先重启主机应用，使已准备的版本生效');
+    if (await isBusy()) throw conflict('有任务正在运行，结束后再更新');
+    return state;
+  };
+  // Reserve mutation admission synchronously, before asynchronous profile/task inspection.
+  let dispatching = false;
+  const dispatch = async input => {
+    if (input.action === 'status') return status();
+    if (closed) throw conflict('更新服务已关闭');
+    if (dispatching || task) throw conflict('更新正在进行，请稍候');
+    dispatching = true;
+    try {
+      switch (input.action) {
+        case 'configure': {
+          const state = await installed();
+          if (state.managed && state.version !== version) throw conflict('请先重启主机应用');
+          const next = normalizeUpdateConfig(input);
+          await mkdir(directory, { recursive: true, mode: 0o700 });
+          const temporary = `${configFile}.${randomUUID()}.tmp`;
+          try { await writeFile(temporary, JSON.stringify(next), { mode: 0o600 }); await rename(temporary, configFile); }
+          finally { await rm(temporary, { force: true }); }
+          config = next; release = null; error = ''; phase = 'idle'; checkedAt = null;
+          break;
+        }
+        case 'check': {
+          phase = 'checking';
+          start('check', async () => {
+            const next = await fetchVerifiedRelease({ config, fetcher: updateFetch, publicKey });
+            release = next;
+            checkedAt = new Date().toISOString(); phase = 'idle';
+          });
+          break;
+        }
+        case 'install': {
+          const state = await guard();
+          if (!release || !engineVersion || !isEngineCompatible(engineVersion, release.engine)) throw conflict('请先检查可兼容的插件版本');
+          if (!isNewerVersion(release.plugin.version, version)) throw conflict('插件已是最新版本');
+          const selected = release;
+          phase = 'downloading';
+          start('install', async () => {
+            const archive = join(state.root, `.download-${randomUUID()}.tar.gz`);
+            try {
+              const bytes = verifyArtifact(await fetchUpdateBytes(selected.plugin.url, { config, fetcher: updateFetch, maxBytes: selected.plugin.size, timeoutMs: 5 * 60_000 }), selected.plugin);
+              if (closed) throw new Error('更新已取消');
+              await mkdir(state.root, { recursive: true, mode: 0o700 });
+              await writeFile(archive, bytes, { mode: 0o600 });
+              const prepared = await install.prepareRelease({ archive, root: state.root, version: selected.plugin.version, runtime });
+              if (closed) throw new Error('更新已取消');
+              if (await isBusy()) throw conflict('下载期间有新任务开始，结束后再点更新');
+              await install.activateRelease({ profile, release: prepared });
+              phase = 'ready';
+            } finally { await rm(archive, { force: true }); }
+          });
+          break;
+        }
+        case 'rollback': {
+          const state = await guard();
+          if (!state.previous) throw conflict('暂无可回退版本');
+          phase = 'downloading';
+          start('rollback', async () => { if (await isBusy()) throw conflict('有任务正在运行'); await install.rollbackRelease({ profile, runtime }); phase = 'ready'; });
+          break;
+        }
+        default: throw new Error('未知更新操作');
+      }
+      return status();
+    } finally { dispatching = false; }
+  };
+  return { dispatch, status, settled: async () => { await task; }, close: async () => { closed = true; lifetime.abort(); await task; } };
+}
+
+export async function mountUpdates(ctx, commander, options = {}) {
+  const context = ctx.get('profileContext');
+  const runtime = context?.installAnchor && dirname(context.installAnchor);
+  const pkg = await json(new URL('../package.json', import.meta.url));
+  let engineVersion;
+  try { engineVersion = (await json(join(runtime, 'node_modules/@deepseek-ai/dsh-app-boot/package.json'))).version; } catch {}
+  const appVersion = context?.name === 'desktop' ? await desktopApplicationVersion() : undefined;
+  const service = await createUpdates({ directory: commander.store.directory, profile: context?.dir, runtime, installation: context?.name === 'desktop' ? 'desktop' : 'server', version: pkg.version, engineVersion, appVersion,
+    isBusy: () => commander.list().some(session => ['running', 'connecting', 'waiting'].includes(session.status)) ||
+      (ctx.get('agents')?.list?.() ?? []).some(agent => agent.status === 'running'), ...options });
+  const fetch = async request => {
+    try {
+      assertSameOrigin(request);
+      if (!request.headers.get('content-type')?.toLowerCase().startsWith('application/json')) throw Object.assign(new Error('Expected application/json'), { status: 415 });
+      const input = JSON.parse(new TextDecoder().decode(await readLimited(request, 4096)));
+      if (!input || typeof input !== 'object' || Array.isArray(input)) throw new Error('请求必须为 JSON 对象');
+      return Response.json(await service.dispatch(input), { headers: { 'cache-control': 'no-store' } });
+    } catch (failure) { return Response.json({ error: failure.message }, { status: failure.status || 400, headers: { 'cache-control': 'no-store' } }); }
+  };
+  ctx.effect(() => ctx.connection.fetch.register({ path: '/api/commander/updates', methods: ['POST'], requestBody: 'buffered', fetch }));
+  ctx.effect(() => () => service.close());
+  return service;
+}

package/src/usage-import-parsers.mjs

@@ -0,0 +1,37 @@
+import { createHash } from 'node:crypto';
+const hash = value => createHash('sha256').update(JSON.stringify(value)).digest('hex').slice(0, 32);
+const known = value => typeof value === 'string' && value.length <= 1024 ? value : null;
+export function parseUsageLine(tool, item, state, normalize) {
+  const p = item.payload ?? {}, m = item.message ?? {};
+  const time = item.timestamp ?? m.timestamp;
+  if (tool === 'codex') {
+    if (item.type === 'session_meta') { state.nativeId = p.id ?? p.session_id; state.contextWindow = p.context_window; state.inherited = p.forked_from_ordinal_exclusive ?? null; }
+    if (item.type === 'turn_context') { state.model = p.model; state.turnId = p.turn_id; }
+    if (state.inherited != null && item.ordinal != null && item.ordinal < state.inherited) return;
+    let usage, cumulative, callId;
+    if (item.type === 'token_usage_record') { usage = p.usage; cumulative = p.thread_token_usage; callId = p.response_id; state.nativeId ??= p.thread_id ?? p.session_id; state.turnId = p.turn_id ?? state.turnId; }
+    else if (item.type === 'event_msg' && p.type === 'token_count') { usage = p.info?.last_token_usage; cumulative = p.info?.total_token_usage; state.contextWindow = p.info?.model_context_window ?? state.contextWindow; }
+    if (!usage || !state.nativeId) return;
+    const signature = hash(cumulative ?? usage);
+    if (state.lastUsageSignature === signature) return;
+    state.lastUsageSignature = signature;
+    // One stable cumulative accounting position is shared by both modern and legacy records.
+    return row(tool, state.nativeId, signature, state.model, time, normalize({ ...usage, contextTokens: usage.input_tokens, contextWindow: state.contextWindow }, 'inclusive'), state.turnId, callId);
+  }
+  if (tool === 'claude' && item.type === 'assistant' && m.usage && m.id) {
+    return row(tool, item.sessionId ?? state.nativeId, m.id, m.model, time, normalize(m.usage), null, m.id);
+  }
+  if (tool === 'pi') {
+    if (item.type === 'session') state.nativeId = item.id;
+    if (item.type === 'model_change') state.model = item.modelId;
+    if (item.type === 'message' && m.role === 'assistant' && m.usage) return row(tool, state.nativeId, item.id ?? String(m.timestamp), m.model ?? state.model, time, normalize(m.usage), null, item.id);
+  }
+}
+function row(tool, nativeId, id, model, time, usage, turnId, callId) {
+  if (!nativeId || !Number.isFinite(new Date(time).getTime())) return;
+  return { id: 'machine:' + tool + ':' + nativeId + ':' + id, source: 'machine', tool, model: known(model), nativeId: known(nativeId), callId: known(callId), sessionId: null, turnId: known(turnId), time: new Date(time).toISOString(), status: 'recorded', ...usage };
+}
+export function parseOpenCodeMessage(info, normalize) {
+  if (info.role !== 'assistant' || !info.tokens || !info.id || !info.sessionID) return;
+  return row('opencode', info.sessionID, info.id, info.modelID ? (info.providerID ? info.providerID + '/' : '') + info.modelID : null, info.time?.completed ?? info.time?.created, normalize(info.tokens), null, info.id);
+}

package/src/usage-import.mjs

@@ -0,0 +1,114 @@
+import { readdir, stat, open, readFile, writeFile, rename, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, basename } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { parseUsageLine, parseOpenCodeMessage } from './usage-import-parsers.mjs';
+
+export function usageRoots(env = process.env, home = homedir()) {
+  const codex = env.CODEX_HOME || join(home, '.codex');
+  return { codex: [join(codex, 'sessions'), join(codex, 'archived_sessions')], claude: [join(env.CLAUDE_CONFIG_DIR || join(home, '.claude'), 'projects')], pi: [join(env.PI_CODING_AGENT_DIR || join(home, '.pi', 'agent'), 'sessions')], opencode: [env.OPENCODE_DATA_DIR || join(env.XDG_DATA_HOME || join(home, '.local', 'share'), 'opencode')] };
+}
+export class MachineUsageImporter {
+  constructor(ledger, normalize, { roots = usageRoots(), maxFiles = 10000, maxBytesPerScan = 32 * 1024 * 1024, maxLineBytes = 8 * 1024 * 1024 } = {}) {
+    this.ledger = ledger; this.normalize = normalize; this.roots = roots; this.limits = { maxFiles, maxBytesPerScan, maxLineBytes }; this.path = join(ledger.path, '..', 'usage-import.json'); this.cursors = {}; this.pending = new Map(); this.completeNativeIds = new Set(); this.coverage = { state: 'idle', sources: [], limits: this.limits }; this.closed = false;
+  }
+  async open() { try { const saved = JSON.parse(await readFile(this.path, 'utf8')); if (saved.version === 1) this.cursors = saved.cursors ?? {}; } catch (e) { if (e.code !== 'ENOENT') this.coverage.error = '扫描游标不可读，将重新安全去重扫描'; } return this; }
+  scan() { if (this.running) return this.running; this.running = this.run().catch(error => { this.coverage.state = 'error'; this.coverage.error = error.code || 'scan-failed'; }).finally(() => { this.running = null; }); return this.running; }
+  async run() {
+    this.completeNativeIds.clear();
+    this.coverage = { state: 'scanning', startedAt: new Date().toISOString(), completedAt: null, sources: [], scannedBytes: 0, limits: this.limits };
+    let budget = this.limits.maxBytesPerScan, filesCount = 0;
+    for (const [tool, roots] of Object.entries(this.roots)) {
+      budget = Math.max(1, Math.floor(this.limits.maxBytesPerScan / Math.max(1, Object.keys(this.roots).length)));
+      const source = { tool, status: 'missing', files: 0, scannedFiles: 0, records: 0, errors: [], truncated: false, continuable: false }; this.coverage.sources.push(source);
+      for (const root of roots) {
+        const paths = [];
+        const walk = async (directory, depth = 0) => {
+          if (depth > 12 || filesCount >= this.limits.maxFiles || this.closed) { source.truncated = true; return; }
+          let entries; try { entries = await readdir(directory, { withFileTypes: true }); source.status = 'ready'; } catch (e) { if (e.code !== 'ENOENT') source.errors.push(e.code || 'read-directory'); return; }
+          for (const entry of entries) { if (entry.isSymbolicLink()) continue; const path = join(directory, entry.name); if (entry.isDirectory()) await walk(path, depth + 1); else if ((tool === 'opencode' && (entry.name.endsWith('.json') || entry.name === 'opencode.db')) || entry.name.endsWith('.jsonl')) { if (++filesCount > this.limits.maxFiles) { source.truncated = true; break; } paths.push(path); } }
+        };
+        await walk(root); source.files += paths.length;
+        for (const path of paths) {
+          if (this.closed || budget <= 0) { source.truncated = true; source.continuable = !this.closed; break; }
+          try {
+            const info = await stat(path);
+            if (tool === 'opencode') { if (path.endsWith('.db')) { const result = await this.sqlite(path, source, budget); budget -= result; this.coverage.scannedBytes += result; } else if (path.includes('/message/')) { if (info.size > this.limits.maxLineBytes || info.size > budget) { source.truncated = true; continue; } const key = path, prior = this.cursors[key]; if (prior?.mtime === info.mtimeMs && prior.size === info.size) continue; const item = JSON.parse(await readFile(path, 'utf8')); const row = parseOpenCodeMessage(item, this.normalize); if (row) this.ledger.put(row); this.cursors[key] = { mtime: info.mtimeMs, size: info.size }; budget -= info.size; this.coverage.scannedBytes += info.size; source.scannedFiles++; } continue; }
+            let cursor = this.cursors[path];
+            if (!cursor || cursor.ino !== info.ino || info.size < cursor.offset) cursor = { ino: info.ino, offset: 0, state: { nativeId: basename(path, '.jsonl') } };
+            let pending = this.pending.get(path);
+            if (pending && (pending.ino !== info.ino || pending.offset !== cursor.offset || info.size < pending.nextOffset)) { this.pending.delete(path); pending = null; }
+            if (pending?.tail && pending.size === info.size && pending.mtime === info.mtimeMs) { source.truncated = true; continue; }
+            if (pending?.tail) { this.pending.delete(path); pending = null; }
+            const readOffset = pending?.nextOffset ?? cursor.offset;
+            const length = Math.min(info.size - readOffset, budget); if (length <= 0) { if (cursor.offset === info.size && cursor.state.nativeId) this.completeNativeIds.add(tool + ':' + cursor.state.nativeId); continue; }
+            const handle = await open(path, 'r'); const fresh = Buffer.alloc(length); let bytesRead;
+            try { ({ bytesRead } = await handle.read(fresh, 0, length, readOffset)); } finally { await handle.close(); }
+            // Keep unfinished bounded records in memory only, never in the cursor file.
+            const buffer = pending?.buffer ? Buffer.concat([pending.buffer, fresh.subarray(0, bytesRead)]) : fresh.subarray(0, bytesRead);
+            let position = 0, consumed = 0;
+            if (cursor.state.skipOversize) {
+              const newline = buffer.indexOf(10);
+              if (newline >= 0) {
+                consumed = newline + 1;
+                cursor.state.skipOversize = false;
+                position = consumed;
+              } else {
+                consumed = buffer.length;
+                position = buffer.length;
+              }
+            }
+            while (position < buffer.length) {
+              const end = buffer.indexOf(10, position); if (end < 0) break;
+              if (end - position > this.limits.maxLineBytes) { source.errors.push('line-too-large'); consumed = end + 1; position = end + 1; continue; }
+              try { const item = JSON.parse(buffer.subarray(position, end).toString('utf8')); const row = parseUsageLine(tool, item, cursor.state, this.normalize); if (row) this.ledger.put(row); } catch { source.errors.push('invalid-json-record'); }
+              consumed = end + 1; position = consumed;
+            }
+            if (buffer.length - consumed > this.limits.maxLineBytes) {
+              source.errors.push('line-too-large');
+              cursor.state.skipOversize = true;
+              consumed = buffer.length;
+            }
+            cursor.offset += consumed; this.cursors[path] = cursor; this.pending.delete(path);
+            const nextOffset = readOffset + bytesRead;
+            if (cursor.offset < nextOffset) {
+              if (nextOffset < info.size) this.pending.set(path, { ino: info.ino, offset: cursor.offset, nextOffset, buffer: buffer.subarray(consumed) });
+              else this.pending.set(path, { ino: info.ino, offset: cursor.offset, nextOffset, tail: true, size: info.size, mtime: info.mtimeMs });
+            }
+            if (cursor.offset === info.size && cursor.state.nativeId && !source.errors.length) this.completeNativeIds.add(tool + ':' + cursor.state.nativeId); else this.completeNativeIds.delete(tool + ':' + cursor.state.nativeId);
+            if (cursor.offset < info.size) source.truncated = true;
+            if (nextOffset < info.size) source.continuable = true;
+            budget -= bytesRead; this.coverage.scannedBytes += bytesRead; source.scannedFiles++;
+          } catch (e) { source.errors.push(e.code || 'read-history'); }
+        }
+      }
+      source.records = [...this.ledger.rows.values()].filter(row => row.source === 'machine' && row.tool === tool).length;
+      source.errors = [...new Set(source.errors)].slice(0, 10); if (source.errors.length || source.truncated) source.status = 'partial';
+    }
+    this.coverage.state = this.coverage.sources.some(source => source.status === 'partial') ? 'partial' : 'ready'; this.coverage.completedAt = new Date().toISOString();
+    await this.ledger.flush();
+    const temp = this.path + '.' + randomUUID() + '.tmp'; try { await writeFile(temp, JSON.stringify({ version: 1, cursors: this.cursors }), { mode: 0o600 }); await rename(temp, this.path); } finally { await rm(temp, { force: true }); }
+  }
+  async sqlite(path, source, budget) {
+    let db;
+    try {
+      const { DatabaseSync } = await import('node:sqlite'); db = new DatabaseSync(path, { readOnly: true });
+      const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name IN ('message','part')").all();
+      if (!tables.some(row => row.name === 'message')) { source.errors.push('unsupported-opencode-schema'); return 0; }
+      const columns = db.prepare('PRAGMA table_info(message)').all().map(row => row.name);
+      if (!columns.includes('data')) { source.errors.push('unsupported-opencode-schema'); return 0; }
+      const file = await stat(path), prior = this.cursors[path];
+      let walTime = 0; try { walTime = (await stat(path + '-wal')).mtimeMs; } catch {}
+      // Usage is often written back into an existing assistant row. A changed DB
+      // restarts a bounded idempotent scan; stable row ids overwrite prior counts.
+      let offset = prior?.mtime === file.mtimeMs && prior?.size === file.size && prior?.walTime === walTime ? prior.rowid ?? 0 : 0, bytes = 0;
+      if (prior?.complete && offset > 0) return 0;
+      const selected = ['rowid AS cursor', 'data', ...(columns.includes('id') ? ['id'] : []), ...(columns.includes('session_id') ? ['session_id'] : [])];
+      const rows = db.prepare('SELECT ' + selected.join(',') + ' FROM message WHERE rowid > ? ORDER BY rowid LIMIT 1000').all(offset);
+      let complete = rows.length < 1000;
+      for (const item of rows) { const size = Buffer.byteLength(String(item.data)); if (bytes + size > budget) { source.truncated = true; complete = false; break; } bytes += size; const info = typeof item.data === 'string' ? JSON.parse(item.data) : item.data; const row = parseOpenCodeMessage({ id: item.id, sessionID: item.session_id, ...info }, this.normalize); if (row) this.ledger.put(row); offset = item.cursor; }
+      this.cursors[path] = { rowid: offset, mtime: file.mtimeMs, walTime, size: file.size, complete }; source.scannedFiles++; if (!complete) { source.truncated = true; source.continuable ||= bytes > 0; } return bytes;
+    } catch (e) { source.errors.push(e.code || 'sqlite-unavailable'); return 0; } finally { db?.close(); }
+  }
+  async close() { this.closed = true; await this.running; }
+}

package/src/usage-timeline.mjs

@@ -0,0 +1,36 @@
+const hour = 3_600_000, day = 24 * hour;
+
+/** Aggregate the filtered, deduplicated interval before history pagination. */
+export function usageTimeline(rows, { start, end, timeZone = 'UTC' }) {
+  const from = Date.parse(start), to = Date.parse(end);
+  const formatter = new Intl.DateTimeFormat('sv-SE', { timeZone, year: 'numeric', month: '2-digit', day: '2-digit' });
+  const localDate = time => formatter.format(new Date(time));
+  const firstDate = localDate(from), lastDate = localDate(to - 1);
+  const interval = firstDate === lastDate ? 'hour' : to - from <= 90 * day ? 'day' : to - from <= 3660 * day ? 'month' : 'year';
+  const periodKey = time => interval === 'hour' ? String(Math.floor((time - from) / hour)) : localDate(time).slice(0, interval === 'day' ? 10 : interval === 'month' ? 7 : 4);
+  const buckets = new Map();
+  const add = (key, time) => buckets.set(key, { time, calls: 0, measuredCalls: 0, totalTokens: null });
+  if (interval === 'hour') {
+    for (let time = from; time < to; time += hour) add(periodKey(time), new Date(time).toISOString());
+  } else {
+    const first = new Date(firstDate + 'T00:00:00Z'), last = new Date(lastDate + 'T00:00:00Z');
+    if (interval !== 'day') { first.setUTCDate(1); last.setUTCDate(1); }
+    if (interval === 'year') { first.setUTCMonth(0); last.setUTCMonth(0); }
+    for (let cursor = first; cursor <= last;) {
+      const key = cursor.toISOString().slice(0, interval === 'day' ? 10 : interval === 'month' ? 7 : 4);
+      add(key, key);
+      if (interval === 'day') cursor.setUTCDate(cursor.getUTCDate() + 1);
+      else if (interval === 'month') cursor.setUTCMonth(cursor.getUTCMonth() + 1);
+      else cursor.setUTCFullYear(cursor.getUTCFullYear() + 1);
+    }
+  }
+  for (const row of rows) {
+    const bucket = buckets.get(periodKey(Date.parse(row.time)));
+    if (!bucket) continue;
+    bucket.calls++;
+    if (row.totalTokens !== null && row.totalTokens !== undefined) {
+      bucket.measuredCalls++; bucket.totalTokens = (bucket.totalTokens ?? 0) + row.totalTokens;
+    }
+  }
+  return { interval, timeZone, buckets: [...buckets.values()].map(bucket => bucket.calls ? bucket : { ...bucket, totalTokens: 0 }) };
+}

package/src/usage.mjs

@@ -0,0 +1,142 @@
+import { readFile, writeFile, rename, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { assertSameOrigin } from '../voice/src/web.mjs';
+import { readJson } from '../voice/src/media.mjs';
+import { MachineUsageImporter } from './usage-import.mjs';
+import { usageTimeline } from './usage-timeline.mjs';
+import { assistantStreamFirstTokenTime } from '@deepseek-ai/dsh-llm';
+
+const count = value => Number.isSafeInteger(value) && value >= 0 ? value : null;
+const sum = values => values.length && values.every(value => value !== null) ? values.reduce((a, b) => a + b, 0) : null;
+export function normalizeUsage(usage = {}, convention = 'disjoint') {
+  const input = count(usage.inputTokens ?? usage.input_tokens ?? usage.input);
+  const outputTokens = count(usage.outputTokens ?? usage.output_tokens ?? usage.output);
+  const cacheReadTokens = count(usage.cacheReadTokens ?? usage.cachedTokens ?? usage.cached_input_tokens ?? usage.cache_read_input_tokens ?? usage.cacheRead ?? usage.cache?.read);
+  const cacheWriteTokens = count(usage.cacheWriteTokens ?? usage.cache_write_input_tokens ?? usage.cache_creation_input_tokens ?? usage.cacheWrite ?? usage.cache?.write);
+  const reportedTotal = count(usage.totalTokens ?? usage.total_tokens ?? usage.total);
+  const promptTokens = convention === 'inclusive' ? input : reportedTotal !== null && outputTokens !== null ? Math.max(0, reportedTotal - outputTokens) : sum([input, cacheReadTokens, cacheWriteTokens]);
+  return { inputTokens: convention === 'inclusive' ? input !== null && cacheReadTokens !== null ? Math.max(0, input - cacheReadTokens) : null : input, outputTokens, cacheReadTokens, cacheWriteTokens,
+    totalTokens: reportedTotal ?? (promptTokens !== null && outputTokens !== null ? promptTokens + outputTokens : null),
+    contextTokens: count(usage.contextTokens) ?? promptTokens, contextWindow: count(usage.contextWindow ?? usage.modelContextWindow), reasoningTokens: count(usage.reasoningTokens ?? usage.reasoning_output_tokens) };
+}
+
+export class UsageLedger {
+  constructor(directory) { this.path = join(directory, 'usage.json'); this.rows = new Map(); this.writes = Promise.resolve(); this.error = null; }
+  async open() {
+    try { const data = JSON.parse(await readFile(this.path, 'utf8')); if (data.version !== 1 || !Array.isArray(data.rows)) throw Error('Unsupported usage ledger'); for (const row of data.rows) this.rows.set(row.id, row); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    return this;
+  }
+  put(row) {
+    // Strict allowlist: never persist prompts, completions, arbitrary event payloads or credentials.
+    const safe = Object.fromEntries(['id', 'tool', 'model', 'time', 'sessionId', 'nativeId', 'callId', 'source', 'turnId', 'status', 'scope', 'durationMs', 'speedOutputTokens', 'inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'totalTokens', 'contextTokens', 'contextWindow', 'reasoningTokens'].map(key => [key, row[key] ?? null]));
+    if (!safe.id || !Number.isFinite(Date.parse(safe.time))) return;
+    const prior = this.rows.get(safe.id);
+    if (prior) {
+      // Historical replay may lack the live execution duration or model metadata.
+      for (const key of Object.keys(safe)) if (safe[key] === null && prior[key] !== null) safe[key] = prior[key];
+    }
+    if (JSON.stringify(prior) === JSON.stringify(safe)) return;
+    this.rows.set(safe.id, safe); this.dirty = true;
+  }
+  flush() {
+    if (!this.dirty) return this.writes; this.dirty = false;
+    const data = JSON.stringify({ version: 1, rows: [...this.rows.values()] });
+    const task = this.writes.then(async () => { const temp = this.path + '.' + randomUUID() + '.tmp'; try { await writeFile(temp, data, { mode: 0o600 }); await rename(temp, this.path); } finally { await rm(temp, { force: true }); } });
+    this.writes = task.catch(error => { this.error = error.message; }); return task;
+  }
+  query({ start, end, page = 1, pageSize = 50, timeZone = 'UTC' } = {}) {
+    if (!Number.isSafeInteger(page) || page < 1 || ![25, 50, 100].includes(pageSize)) throw Error('无效的分页参数');
+    const from = Date.parse(start), to = Date.parse(end);
+    if (!Number.isFinite(from) || !Number.isFinite(to) || to <= from) throw Error('请选择有效起止日期');
+    let excludedDuplicates = 0;
+    const managed = this.managed?.() ?? new Map(), imported = new Set([...this.rows.values()].filter(row => row.source === 'machine').map(row => row.tool + ':' + row.nativeId));
+    const preferred = new Set([...managed.values()].filter(key => imported.has(key) && this.importer?.coverage.state !== 'scanning' && this.importer?.completeNativeIds.has(key)));
+    const rows = [...this.rows.values()].filter(row => {
+      const nativeKey = row.source === 'machine' ? row.tool + ':' + row.nativeId : managed.get(row.sessionId);
+      const duplicate = row.source === 'machine' ? [...managed.values()].includes(nativeKey) && !preferred.has(nativeKey) : nativeKey && preferred.has(nativeKey);
+      if (duplicate) { excludedDuplicates++; return false; }
+      const time = Date.parse(row.time); return time >= from && time < to;
+    }).sort((a, b) => b.time.localeCompare(a.time));
+    const groups = new Map();
+    for (const row of rows) { const key = JSON.stringify([row.tool, row.model]); if (!groups.has(key)) groups.set(key, []); groups.get(key).push(row); }
+    const summarize = group => {
+      const total = field => sum(group.map(row => row[field]));
+      const cacheReadTokens = total('cacheReadTokens'), inputTokens = total('inputTokens'), cacheWriteTokens = total('cacheWriteTokens');
+      const prompt = sum(group.map(row => row.totalTokens !== null && row.outputTokens !== null ? row.totalTokens - row.outputTokens : sum([row.inputTokens, row.cacheReadTokens, row.cacheWriteTokens])));
+      const timed = group.filter(row => row.durationMs > 0 && row.outputTokens !== null);
+      const context = group.filter(row => row.contextTokens !== null).sort((a, b) => b.contextTokens - a.contextTokens)[0];
+      return { calls: group.length, inputTokens, outputTokens: total('outputTokens'), totalTokens: total('totalTokens'), cacheReadTokens, cacheWriteTokens,
+        cacheHitRate: prompt > 0 && cacheReadTokens !== null ? cacheReadTokens / prompt : null, contextTokens: context?.contextTokens ?? null,
+        contextWindow: context?.contextWindow ?? null, tokensPerSecond: timed.length ? timed.reduce((n, row) => n + (row.speedOutputTokens ?? row.outputTokens), 0) / timed.reduce((n, row) => n + row.durationMs / 1000, 0) : null, measuredCalls: group.filter(row => row.totalTokens !== null).length };
+    };
+    const timeline = usageTimeline(rows, { start, end, timeZone });
+    const pageCount = Math.max(1, Math.ceil(rows.length / pageSize)), currentPage = Math.min(page, pageCount);
+    return { start, end, timeline, page: currentPage, pageSize, pageCount, summary: summarize(rows), groups: [...groups.values()].map(group => ({ tool: group[0].tool, model: group[0].model, ...summarize(group) })), records: rows.slice((currentPage - 1) * pageSize, currentPage * pageSize), recordCount: rows.length, error: this.error, coverage: { ...(this.importer?.coverage ?? { state: 'idle', sources: [] }), excludedDuplicates, deduplication: '完整导入的原生会话以本机历史为准；未完整导入的已管理会话保留实时记录，不叠加历史；未匹配会话按原生调用标识独立统计' } };
+  }
+}
+
+export async function mountUsage(ctx, commander, options = {}) {
+  let ledger;
+  try { ledger = await new UsageLedger(commander.store.directory).open(); }
+  catch (error) { ledger = new UsageLedger(commander.store.directory); ledger.error = '历史用量无法读取，本次仅显示内存采集；原文件保留。'; ledger.flush = () => Promise.resolve(); }
+  ledger.managed = () => new Map([...commander.sessions.values()].filter(session => session.nativeId).map(session => [session.id, session.provider + ':' + (session.provider === 'pi' ? session.nativeId.split('/').at(-1)?.replace(/.jsonl$/u, '').split('_').at(-1) : session.nativeId)]));
+  ledger.importer = await new MachineUsageImporter(ledger, normalizeUsage, options.enabled === false ? { roots: {} } : options).open();
+  let scanTimer, scanRounds = 0;
+  const scanMachine = async () => { await ledger.importer.scan(); scanRounds++; if (!ledger.importer.closed && scanRounds < 100 && ledger.importer.coverage.scannedBytes > 0 && ledger.importer.coverage.sources.some(source => source.continuable)) { scanTimer = setTimeout(scanMachine, 1000); scanTimer.unref?.(); } };
+  void scanMachine();
+  const routes = new Map(), stepFirst = new Map(); let stopped = false, backfill;
+  // Earlier versions measured entire native turns. Remove those incompatible
+  // intervals rather than mixing them into the official settled-step speed.
+  for (const row of ledger.rows.values()) if (row.id.startsWith('native:') && (row.durationMs !== null || row.speedOutputTokens !== null)) { row.durationMs = null; row.speedOutputTokens = null; ledger.dirty = true; }
+  const native = event => {
+    const session = commander.sessions.get(event.sessionId); if (!session) return;
+    const key = session.id + ':' + event.turnId;
+    if (event.type === 'usage') {
+      const id = 'native:' + key + ':' + (event.data.id ?? 'turn');
+      const old = ledger.rows.get(id);
+      ledger.put({ ...old, id, tool: session.provider, model: event.data.model ?? session.model ?? null, time: event.time, sessionId: session.id, turnId: event.turnId, status: session.status, scope: event.data.scope, ...normalizeUsage(event.data.usage, event.data.convention), durationMs: count(event.data.durationMs) ?? old?.durationMs ?? null });
+    }
+    // Legacy Claude message events already carry authoritative per-message usage.
+    if (event.type === 'message' && session.provider === 'claude' && event.data.type === 'assistant' && event.data.message?.usage) {
+      const message = event.data.message; ledger.put({ id: 'native:' + key + ':' + (message.id ?? event.seq), tool: session.provider, model: message.model ?? session.model ?? null, time: event.time, sessionId: session.id, turnId: event.turnId, status: session.status, durationMs: null, ...normalizeUsage(message.usage) });
+    }
+    if (event.type === 'turn.completed') {
+      const turnRows = [...ledger.rows.values()].filter(row => row.sessionId === session.id && row.turnId === event.turnId);
+      for (const row of turnRows) ledger.put({ ...row, status: event.data.status, durationMs: null, speedOutputTokens: null });
+      if (![...ledger.rows.values()].some(row => row.sessionId === session.id && row.turnId === event.turnId)) ledger.put({ id: 'native:' + key + ':turn', tool: session.provider, model: session.model, time: event.time, sessionId: session.id, turnId: event.turnId, status: event.data.status });
+    }
+  };
+  for (const session of commander.sessions.values()) for (const event of session.events) native(event);
+  const listener = event => { native(event); void ledger.flush().catch(() => {}); }; commander.on('event', listener);
+  const official = (session, event) => {
+    if (event.type === 'request/header') { routes.set(session.id, event.data.header?.config ?? {}); return; }
+    if (!['assistant/message', 'assistant/attempt'].includes(event.type) || event.seq < (session.inheritedEventCount ?? 0)) return;
+    const source = event.data.message?.source ?? routes.get(session.id) ?? {};
+    if (source.provider?.startsWith('commander-')) return;
+    const stream = event.data.stream ?? []; const usage = event.data.usage ?? stream.filter(record => record.chunk?.type === 'usage').at(-1)?.chunk?.usage;
+    const stepKey = session.id + ':' + event.data.turn + ':' + event.data.step;
+    const first = assistantStreamFirstTokenTime(stream), pending = stepFirst.get(stepKey);
+    const firstTime = Number.isFinite(first) ? Number.isFinite(pending) ? Math.min(first, pending) : first : pending;
+    if (event.type === 'assistant/attempt') {
+      if (Number.isFinite(firstTime)) stepFirst.set(stepKey, firstTime);
+      if (ledger.rows.delete('harness:' + session.id + ':' + event.seq)) ledger.dirty = true;
+      return;
+    }
+    stepFirst.delete(stepKey);
+    if (!usage && event.type !== 'assistant/message') return;
+    const durationMs = Number.isFinite(firstTime) && event.time > firstTime ? event.time - firstTime : null;
+    ledger.put({ id: 'harness:' + session.id + ':' + event.seq, tool: source.provider ?? 'harness', model: source.model ?? null, time: new Date(event.time).toISOString(), sessionId: session.id, turnId: String(event.data.turn), status: event.data.interrupted ? 'interrupted' : 'completed', durationMs, ...normalizeUsage(usage ?? {}) });
+  };
+  ctx.on('session/event', (session, event) => { official(session, event); void ledger.flush().catch(() => {}); });
+  ctx.inject(['sessionQuery'], child => {
+    backfill = (async () => { for (const record of await child.sessionQuery.listSessions()) { if (stopped) return; try { const snapshot = await child.sessionQuery.readSession(record.header.id); const session = { id: record.header.id, inheritedEventCount: snapshot.inheritedEventCount }; for (const event of snapshot.events) official(session, event); } catch { /* Unreadable old sessions must not prevent current usage collection. */ } } await ledger.flush(); })().catch(error => { ledger.error = error.message; });
+  });
+  ctx.effect(() => ctx.connection.fetch.register({ path: '/api/commander/usage', methods: ['POST'], requestBody: 'buffered', async fetch(request) {
+    try { assertSameOrigin(request); const input = await readJson(request); await backfill; if (input.refresh === true) await ledger.importer.scan(); return Response.json(ledger.query(input), { headers: { 'cache-control': 'no-store' } }); }
+    catch (error) { return Response.json({ error: error.message }, { status: 400 }); }
+  } }));
+  ctx.effect(() => async () => { stopped = true; clearTimeout(scanTimer); commander.off('event', listener); await backfill; await ledger.importer.close(); await ledger.flush(); });
+  await ledger.flush(); return ledger;
+}