Token Tracker 入门到精通：纯本地 AI 编程工具 Token 用量追踪实战

import { existsSync, readdirSync, readFileSync } from 'node:fs';
import { homedir } from 'node:os';
import { join } from 'node:path';

const args = new Set(process.argv.slice(2));
const outputJson = args.has('--json');

function getPossibleRoots() {
  const home = homedir();
  const roots = [
    join(home, '.clawdbot'),
    join(home, '.moltbot'),
    join(home, '.moldbot'),
  ];

  try {
    for (const entry of readdirSync(home, { withFileTypes: true })) {
      if (!entry.isDirectory()) continue;
      if (entry.name === '.openclaw' || /^\.openclaw-.+/.test(entry.name)) {
        roots.push(join(home, entry.name));
      }
    }
  } catch {
    // ignore unreadable entries in home directory
  }

  return roots;
}

function getTokenValue(usage, ...keys) {
  for (const key of keys) {
    if (usage[key] != null && usage[key] > 0) return usage[key];
  }
  return 0;
}

function emptyStats() {
  return {
    input: 0,
    output: 0,
    cacheRead: 0,
    cacheWrite: 0,
    total: 0,
    cost: 0,
  };
}

function addStats(target, entry) {
  target.input += entry.input;
  target.output += entry.output;
  target.cacheRead += entry.cacheRead;
  target.cacheWrite += entry.cacheWrite;
  target.total += entry.total;
  target.cost += entry.cost;
}

function parseOpenClaw() {
  const entries = [];

  for (const root of getPossibleRoots()) {
    const agentsDir = join(root, 'agents');
    if (!existsSync(agentsDir)) continue;

    let agentDirs;
    try {
      agentDirs = readdirSync(agentsDir, { withFileTypes: true }).filter(
        entry => entry.isDirectory()
      );
    } catch {
      continue;
    }

    for (const agentDir of agentDirs) {
      const project = agentDir.name;
      const sessionsDir = join(agentsDir, project, 'sessions');
      if (!existsSync(sessionsDir)) continue;

      let files;
      try {
        files = readdirSync(sessionsDir).filter(name => name.endsWith('.jsonl'));
      } catch {
        continue;
      }

      for (const file of files) {
        const filePath = join(sessionsDir, file);
        let content;
        try {
          content = readFileSync(filePath, 'utf8');
        } catch {
          continue;
        }

        for (const line of content.split('\n')) {
          if (!line.trim()) continue;

          try {
            const obj = JSON.parse(line);
            if (obj.type !== 'message') continue;

            const message = obj.message;
            if (!message || message.role !== 'assistant' || !message.usage) continue;

            const rawTs = obj.timestamp ?? message.timestamp;
            if (!rawTs) continue;

            const timestamp = new Date(rawTs);
            if (Number.isNaN(timestamp.getTime())) continue;

            const usage = message.usage;
            const input = getTokenValue(
              usage,
              'input',
              'inputTokens',
              'input_tokens',
              'promptTokens',
              'prompt_tokens'
            );
            const output = getTokenValue(
              usage,
              'output',
              'outputTokens',
              'output_tokens',
              'completionTokens',
              'completion_tokens'
            );
            const cacheRead = getTokenValue(
              usage,
              'cacheRead',
              'cache_read',
              'cache_read_input_tokens'
            );
            const cacheWrite = getTokenValue(
              usage,
              'cacheWrite',
              'cache_write',
              'cache_creation_input_tokens'
            );

            const total =
              usage.totalTokens ??
              usage.total_tokens ??
              input + output + cacheRead + cacheWrite;

            const cost =
              usage.cost?.total ??
              usage.cost?.amount ??
              usage.totalCost ??
              0;

            entries.push({
              project,
              model: message.model || obj.model || 'unknown',
              timestamp,
              input,
              output,
              cacheRead,
              cacheWrite,
              total,
              cost,
            });
          } catch {
            continue;
          }
        }
      }
    }
  }

  return entries;
}

function localDayKey(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  return `${year}-${month}-${day}`;
}

function summarize(entries) {
  const now = new Date();
  const todayStart = new Date(now);
  todayStart.setHours(0, 0, 0, 0);

  const weekStart = new Date(now);
  weekStart.setDate(now.getDate() - 6);
  weekStart.setHours(0, 0, 0, 0);

  const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);

  const total = emptyStats();
  const today = emptyStats();
  const week = emptyStats();
  const month = emptyStats();
  const byModel = new Map();
  const byProject = new Map();
  const byDay = new Map();

  for (const entry of entries) {
    addStats(total, entry);

    if (entry.timestamp >= todayStart) addStats(today, entry);
    if (entry.timestamp >= weekStart) addStats(week, entry);
    if (entry.timestamp >= monthStart) addStats(month, entry);

    if (!byModel.has(entry.model)) byModel.set(entry.model, emptyStats());
    addStats(byModel.get(entry.model), entry);

    if (!byProject.has(entry.project)) byProject.set(entry.project, emptyStats());
    addStats(byProject.get(entry.project), entry);

    const dayKey = localDayKey(entry.timestamp);
    if (!byDay.has(dayKey)) byDay.set(dayKey, emptyStats());
    addStats(byDay.get(dayKey), entry);
  }

  return {
    scannedMessages: entries.length,
    total,
    today,
    week,
    month,
    byModel: Object.fromEntries(
      [...byModel.entries()].sort((a, b) => b[1].total - a[1].total)
    ),
    byProject: Object.fromEntries(
      [...byProject.entries()].sort((a, b) => b[1].total - a[1].total)
    ),
    byDay: Object.fromEntries([...byDay.entries()].sort()),
  };
}

function shortNumber(value) {
  if (value >= 1_000_000) return `${(value / 1_000_000).toFixed(2)}M`;
  if (value >= 1_000) return `${(value / 1_000).toFixed(1)}K`;
  return `${value}`;
}

function printStats(label, stats) {
  console.log(
    `${label.padEnd(8)} 输入 ${shortNumber(stats.input).padStart(8)} | 输出 ${shortNumber(stats.output).padStart(8)} | 总量 ${shortNumber(stats.total).padStart(8)} | 费用 $${stats.cost.toFixed(4)}`
  );
}

function main() {
  const entries = parseOpenClaw();
  const result = summarize(entries);

  if (outputJson) {
    console.log(JSON.stringify(result, null, 2));
    return;
  }

  console.log('Token Tracker（OpenClaw 本地版）');
  console.log('');
  console.log(`解析到 ${result.scannedMessages} 条带 usage 的 assistant 消息`);
  console.log('');
  printStats('总计', result.total);
  printStats('今日', result.today);
  printStats('近 7 天', result.week);
  printStats('本月', result.month);

  console.log('');
  console.log('按模型');
  for (const [model, stats] of Object.entries(result.byModel).slice(0, 10)) {
    printStats(model, stats);
  }

  console.log('');
  console.log('按项目');
  for (const [project, stats] of Object.entries(result.byProject).slice(0, 10)) {
    printStats(project, stats);
  }
}

main();