tokmax 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Eugene Shilow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,96 @@
+# tokmax
+
+Считает, сколько токенов ты сжёг в **Codex** и **Claude Code** на этой машине,
+переводит это в **API-equivalent** доллары и публикует агрегат на публичный
+лидерборд [tokenmax.ru](https://tokenmax.ru).
+
+Одной командой:
+
+```bash
+npx tokmax <nick>
+```
+
+После публикации твой профиль виден на `https://tokenmax.ru/<nick>`.
+
+## Что именно уходит наружу (и что — нет)
+
+Это инструмент про доверие, поэтому граница жёсткая и проверяемая в коде
+(`src/adapters/*.mjs`):
+
+- **Уходит только агрегат:** числа токенов по моделям (`input`, `output`,
+  `cacheCreate`, `cacheRead`, `reasoning`), даты дней и метка машины.
+- **Никогда не уходит:** текст промптов, содержимое файлов, вывод инструментов,
+  API-ключи, сырые строки логов. Адаптеры читают из лога ровно четыре-пять
+  числовых полей usage + id модели + timestamp и выкидывают всё остальное.
+
+Открытый исходник — чтобы это можно было прочитать самому, а не верить на слово.
+
+## Установка и запуск
+
+Нужен Node.js >= 18. Зависимостей в рантайме — ноль (только встроенные модули
+Node и глобальный `fetch`).
+
+```bash
+# разово, без установки
+npx tokmax <nick>
+
+# или глобально
+npm i -g tokmax
+tokenmax <nick>
+```
+
+### Опции
+
+```text
+tokenmax <nick> [options]
+
+  --since YYYY-MM-DD   считать только с этого дня (по умолчанию — вся история)
+  --key <secret>       capability-токен для обновления уже занятого ника
+  --api <baseUrl>      базовый URL API
+  --machine <label>    метка машины (по умолчанию hostname)
+  --dry-run            показать превью и тело запроса, ничего не публиковать
+  --yes, -y            не спрашивать подтверждение
+  --help, -h           справка
+```
+
+`--dry-run` показывает превью и точное тело запроса, которое ушло бы на сервер —
+удобно убедиться глазами, что наружу идут только числа.
+
+## Как считается доллар
+
+CLI забирает прайсинг с `/api/tmx/pricing` и считает превью **той же формулой**,
+что сервер применяет при публикации, поэтому превью == опубликованное число.
+Стоимость = сумма по моделям от
+`(input·r.input + output·r.output + cacheCreate·r.cacheCreate +
+cacheRead·r.cacheRead + reasoning·r.reasoning) / 1e6`, где `r` — ставки
+per-million для распознанной модели (или fallback для незнакомой).
+
+Сервер пересчитывает доллар авторитетно из присланных токенов — CLI ничего не
+может «накрутить».
+
+## Откуда берутся числа
+
+- **Claude Code:** `~/.claude*/projects/**/*.jsonl` — usage из assistant-сообщений
+  (`message.usage`).
+- **Codex:** `~/.codex/sessions/**/*.jsonl` и `~/.codex/archived_sessions/*.jsonl`
+  — события `token_count` (дельты per-turn).
+
+Каждый источник изолирован в свой адаптер (`src/adapters/`) и работает
+защитно: битые строки и отсутствующие поля просто пропускаются (по умолчанию 0).
+
+## Capability-токен
+
+При первой публикации ника сервер возвращает секрет, который CLI кладёт в
+`~/.config/tokenmax/<nick>.json` (права `0600`). Он нужен, чтобы
+позже **обновлять** свой ник. Не теряй его; для обновления на другой машине
+передай его через `--key <secret>`.
+
+## Endpoint
+
+По умолчанию CLI ходит в изолированный tokenmax-деплой
+(`https://chatty-boar-479.convex.site`), где живут hardened-роуты публикации и
+прайсинга. Переопределить можно флагом `--api <baseUrl>`.
+
+## Лицензия
+
+MIT — см. [LICENSE](LICENSE).

package/bin/tokmax.mjs

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+//
+// tokenmax — scan local Codex + Claude Code logs, aggregate per-model
+// token usage, preview the API-equivalent $, and publish the aggregate to the
+// tokenmax leaderboard (tokenmax.ru).
+//
+// Happy path is one command:
+//   npx tokmax <nick>
+//
+// SAFETY INVARIANT: only numeric token aggregates per model + dates leave this
+// machine. Never prompt text, file contents, API keys, or raw log lines.
+
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { readFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+
+import { scanClaudeCode } from '../src/adapters/claude-code.mjs';
+import { scanCodex } from '../src/adapters/codex.mjs';
+import { aggregate } from '../src/aggregate.mjs';
+import { fetchPricing, previewCost } from '../src/pricing.mjs';
+import { publish } from '../src/publish.mjs';
+import { loadSecret, saveSecret } from '../src/secrets.mjs';
+
+const DEFAULT_API = 'https://chatty-boar-479.convex.site';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function parseArgs(argv) {
+  const opts = {
+    nick: null,
+    since: null,
+    key: null,
+    api: DEFAULT_API,
+    machine: os.hostname(),
+    dryRun: false,
+    yes: false,
+    help: false,
+  };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case '--since':
+        opts.since = argv[++i];
+        break;
+      case '--key':
+        opts.key = argv[++i];
+        break;
+      case '--api':
+        opts.api = argv[++i];
+        break;
+      case '--machine':
+        opts.machine = argv[++i];
+        break;
+      case '--dry-run':
+        opts.dryRun = true;
+        break;
+      case '--yes':
+      case '-y':
+        opts.yes = true;
+        break;
+      case '--help':
+      case '-h':
+        opts.help = true;
+        break;
+      default:
+        if (a && a.startsWith('-')) {
+          console.error(`Неизвестный флаг: ${a}`);
+          process.exit(2);
+        }
+        rest.push(a);
+    }
+  }
+  if (!opts.nick && rest.length) opts.nick = rest[0];
+  if (opts.api) opts.api = opts.api.replace(/\/+$/, '');
+  return opts;
+}
+
+const HELP = `tokmax <nick> [options]
+
+  Сканирует локальные логи Codex и Claude Code, считает токены по моделям,
+  показывает API-equivalent в долларах и публикует агрегат на лидерборд
+  tokenmax.ru. Наружу уходят только числа — не логи и не ключи.
+
+Options:
+  --since YYYY-MM-DD   считать только с этого дня (по умолчанию — вся история)
+  --key <secret>       capability-токен для обновления уже занятого ника
+  --api <baseUrl>      базовый URL API (по умолчанию tokenmax deployment)
+  --machine <label>    метка машины (по умолчанию hostname)
+  --dry-run            показать превью и тело запроса, ничего не публиковать
+  --yes, -y            не спрашивать подтверждение
+  --help, -h           показать эту справку`;
+
+function fmtUsd(n) {
+  return n.toLocaleString('en-US', {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+  });
+}
+
+function fmtInt(n) {
+  return n.toLocaleString('en-US');
+}
+
+async function readPackageVersion() {
+  try {
+    const pkg = JSON.parse(
+      await readFile(path.join(__dirname, '..', 'package.json'), 'utf8'),
+    );
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function confirm(question) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    console.log(HELP);
+    return 0;
+  }
+  if (!opts.nick) {
+    console.error('Укажи ник: npx tokmax <nick>  (--help для справки)');
+    return 2;
+  }
+  if (opts.since && !/^\d{4}-\d{2}-\d{2}$/.test(opts.since)) {
+    console.error(`--since должен быть YYYY-MM-DD, получено: ${opts.since}`);
+    return 2;
+  }
+
+  const nick = opts.nick.trim();
+  const nickKey = nick.toLowerCase();
+  const cliVersion = await readPackageVersion();
+
+  console.log(`tokmax v${cliVersion} · ник: ${nick}`);
+  console.log('Сканирую локальные логи…');
+
+  const [claude, codex] = await Promise.all([scanClaudeCode(), scanCodex()]);
+
+  console.log(
+    `  Claude Code: ${claude.sessionCount} сессий · Codex: ${codex.sessionCount} сессий`,
+  );
+
+  const agg = aggregate([claude, codex], { since: opts.since });
+
+  if (!agg.models.length || agg.totalTokens === 0) {
+    console.error(
+      'Не нашёл токенов в логах (с учётом --since). Публиковать нечего.',
+    );
+    return 1;
+  }
+
+  let pricing;
+  try {
+    pricing = await fetchPricing(opts.api);
+  } catch (err) {
+    console.error(`Не удалось получить прайсинг: ${err.message}`);
+    return 1;
+  }
+
+  const usd = previewCost(pricing, agg.models);
+
+  console.log(
+    `Период: ${agg.firstDay} → ${agg.lastDay} (всё, что нашлось)` +
+      (opts.since ? ` · фильтр --since ${opts.since}` : ''),
+  );
+  console.log('Модели:');
+  for (const m of agg.models) {
+    const tot = m.input + m.output + m.cacheCreate + m.cacheRead + m.reasoning;
+    console.log(`  ${m.tool}/${m.model}: ${fmtInt(tot)} токенов`);
+  }
+  console.log(`Всего токенов: ${fmtInt(agg.totalTokens)}`);
+  console.log(`API-equivalent: $${fmtUsd(usd)}`);
+  console.log('Наружу уйдёт только агрегат (числа), не логи и не ключи.');
+
+  const body = {
+    nick,
+    cliVersion,
+    pricingVersion: pricing.version,
+    firstDay: agg.firstDay,
+    lastDay: agg.lastDay,
+    machineLabel: opts.machine,
+    models: agg.models,
+    daily: agg.daily,
+  };
+
+  if (opts.dryRun) {
+    console.log('\n--dry-run: тело запроса, которое было бы отправлено:');
+    console.log(JSON.stringify(body, null, 2));
+    console.log('\n(ничего не опубликовано)');
+    return 0;
+  }
+
+  // Capability token: explicit --key wins, else a saved secret for this nick.
+  const savedSecret = await loadSecret(nickKey);
+  const secret = opts.key || savedSecret;
+  if (secret) body.secret = secret;
+
+  if (!opts.yes) {
+    const ok = await confirm(`Опубликовать как ${nick}? [y/N] `);
+    if (!ok) {
+      console.log('Отменено.');
+      return 0;
+    }
+  }
+
+  const { status, json } = await publish(opts.api, body);
+
+  if (!json) {
+    console.error(`Неожиданный ответ сервера: HTTP ${status}`);
+    return 1;
+  }
+
+  if (json.ok) {
+    if (json.created && json.secret) {
+      const file = await saveSecret(nickKey, {
+        nick: json.nick || nickKey,
+        secret: json.secret,
+        url: json.url,
+        createdAt: Date.now(),
+      });
+      console.log(`\nСохранил capability-токен: ${file} (chmod 600)`);
+      console.log('Не теряй его — он нужен для будущих обновлений ника.');
+    } else {
+      console.log('\nОбновил существующий профиль.');
+    }
+    console.log(`costUsd: $${fmtUsd(json.costUsd)} · токенов: ${fmtInt(json.totalTokens)}`);
+    if (json.suspicious) {
+      console.log('⚠️  Сервер пометил сабмит как suspicious (на ручную проверку).');
+    }
+    console.log(`\n  ${json.url}\n`);
+    return 0;
+  }
+
+  // Documented error reasons.
+  switch (json.reason) {
+    case 'nick_taken':
+      console.error(`Ник занят: ${json.message || nick}`);
+      if (json.suggestion) console.error(`Попробуй: ${json.suggestion}`);
+      console.error(
+        'Если это твой ник — обнови через --key <secret> (capability-токен).',
+      );
+      return 1;
+    case 'rate_limited':
+      console.error(`Слишком часто: ${json.message || 'rate limited'}`);
+      return 1;
+    case 'nick_invalid':
+      console.error(`Недопустимый ник: ${json.message || nick}`);
+      return 1;
+    case 'empty_usage':
+      console.error('Сервер: пустой агрегат (empty_usage).');
+      return 1;
+    case 'invalid_payload':
+      console.error(`Некорректное тело запроса: ${json.message || ''}`);
+      return 1;
+    default:
+      console.error(`Ошибка публикации (HTTP ${status}): ${JSON.stringify(json)}`);
+      return 1;
+  }
+}
+
+main()
+  .then((code) => process.exit(code || 0))
+  .catch((err) => {
+    console.error(`Сбой: ${err && err.stack ? err.stack : err}`);
+    process.exit(1);
+  });

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "tokmax",
+  "version": "0.1.0",
+  "description": "Scan your local Codex + Claude Code logs, aggregate per-model token usage, and publish the API-equivalent $ to the tokenmax leaderboard (tokenmax.ru). Aggregates only — never your prompts, files, or keys.",
+  "type": "module",
+  "bin": {
+    "tokmax": "bin/tokmax.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eugeneshilow/tokmax.git"
+  },
+  "homepage": "https://tokenmax.ru",
+  "keywords": [
+    "codex",
+    "claude-code",
+    "tokens",
+    "usage",
+    "leaderboard",
+    "tokenmax",
+    "vibecoding"
+  ],
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node bin/tokmax.mjs"
+  }
+}

package/src/adapters/claude-code.mjs

@@ -0,0 +1,86 @@
+// Claude Code adapter.
+//
+// Reads ~/.claude*/projects/**/*.jsonl. Each line is a JSON event; assistant
+// messages carry message.usage and message.model plus a top-level ISO
+// timestamp. We extract ONLY numeric token counts + the model id + the day.
+//
+// SAFETY INVARIANT: this module never reads, stores, or transmits prompt text,
+// tool output, file contents, or keys. It pulls four integers and a model name
+// out of `message.usage` / `message.model` and discards everything else.
+
+import os from 'node:os';
+import path from 'node:path';
+import { readdir, readFile } from 'node:fs/promises';
+import { num, isoDay, walkJsonl, lines } from '../util.mjs';
+
+/** All ~/.claude* directories that contain a projects/ tree. */
+async function claudeProjectRoots() {
+  const home = os.homedir();
+  let entries;
+  try {
+    entries = await readdir(home, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const roots = [];
+  for (const e of entries) {
+    // Match the .claude directory and any sibling like .claude-foo, but not
+    // files such as .claude.json.
+    if (e.isDirectory() && e.name.startsWith('.claude')) {
+      roots.push(path.join(home, e.name, 'projects'));
+    }
+  }
+  return roots;
+}
+
+/**
+ * @returns {Promise<{ tool:'claude-code', sessionCount:number, records:Array }>}
+ * records: { tool, model, date, input, output, cacheCreate, cacheRead, reasoning }
+ */
+export async function scanClaudeCode() {
+  const records = [];
+  let sessionCount = 0;
+
+  for (const root of await claudeProjectRoots()) {
+    for await (const file of walkJsonl(root)) {
+      let text;
+      try {
+        text = await readFile(file, 'utf8');
+      } catch {
+        continue;
+      }
+      sessionCount++;
+      for (const line of lines(text)) {
+        let d;
+        try {
+          d = JSON.parse(line);
+        } catch {
+          continue; // skip malformed lines defensively
+        }
+        if (!d || d.type !== 'assistant') continue;
+        const msg = d.message;
+        const usage = msg && msg.usage;
+        if (!usage) continue;
+
+        const model = String((msg && msg.model) || 'unknown');
+        if (model === '<synthetic>') continue; // not a real billed turn
+
+        const date = isoDay(d.timestamp);
+        if (!date) continue;
+
+        records.push({
+          tool: 'claude-code',
+          model,
+          date,
+          input: num(usage.input_tokens),
+          output: num(usage.output_tokens),
+          cacheCreate: num(usage.cache_creation_input_tokens),
+          cacheRead: num(usage.cache_read_input_tokens),
+          reasoning: 0,
+        });
+      }
+    }
+  }
+
+  return { tool: 'claude-code', sessionCount, records };
+}

package/src/adapters/codex.mjs

@@ -0,0 +1,113 @@
+// Codex adapter.
+//
+// Reads ~/.codex/sessions/**/*.jsonl and ~/.codex/archived_sessions/*.jsonl.
+// Each line is a JSON event with { timestamp, type, payload }.
+//
+// Usage events look like:
+//   { type:'event_msg', payload:{ type:'token_count', info:{
+//       total_token_usage:{...cumulative...},
+//       last_token_usage:{ input_tokens, cached_input_tokens, output_tokens,
+//                          reasoning_output_tokens, total_tokens } } } }
+// `last_token_usage` is the per-turn DELTA; summing the deltas across a session
+// equals the final `total_token_usage` (verified on real logs), so deltas give
+// correct per-day buckets with no double counting.
+//
+// Codex accounting nests its buckets: input_tokens INCLUDES cached_input_tokens,
+// and output_tokens INCLUDES reasoning_output_tokens (input + output ==
+// total_tokens). The leaderboard server treats input/output/cacheCreate/
+// cacheRead/reasoning as DISJOINT additive buckets, so we split them:
+//   cacheRead = cached_input_tokens
+//   input     = input_tokens  - cached_input_tokens
+//   reasoning = reasoning_output_tokens
+//   output    = output_tokens - reasoning_output_tokens
+//   cacheCreate = 0  (Codex does not report cache creation separately)
+//
+// The model id is not on the token_count event; it is declared on `turn_context`
+// (payload.model) and `session_meta`, which precede the turn's usage. We track
+// the most recent model id and attribute usage to it.
+//
+// SAFETY INVARIANT: this module never reads, stores, or transmits prompt text,
+// tool output, file contents, or keys — only token integers, the model id, and
+// the day.
+
+import os from 'node:os';
+import path from 'node:path';
+import { readFile } from 'node:fs/promises';
+import { num, isoDay, walkJsonl, lines } from '../util.mjs';
+
+const DEFAULT_MODEL = 'gpt-5.5';
+
+/**
+ * @returns {Promise<{ tool:'codex', sessionCount:number, records:Array }>}
+ */
+export async function scanCodex() {
+  const home = os.homedir();
+  const dirs = [
+    path.join(home, '.codex', 'sessions'),
+    path.join(home, '.codex', 'archived_sessions'),
+  ];
+
+  const records = [];
+  let sessionCount = 0;
+
+  for (const dir of dirs) {
+    for await (const file of walkJsonl(dir)) {
+      let text;
+      try {
+        text = await readFile(file, 'utf8');
+      } catch {
+        continue;
+      }
+      sessionCount++;
+
+      let curModel = DEFAULT_MODEL;
+      for (const line of lines(text)) {
+        let d;
+        try {
+          d = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const p = (d && d.payload) || {};
+
+        // Track the active model from whichever event last declared one.
+        if (typeof p.model === 'string' && p.model) {
+          curModel = p.model;
+        } else if (
+          p.collaboration_mode &&
+          p.collaboration_mode.settings &&
+          typeof p.collaboration_mode.settings.model === 'string' &&
+          p.collaboration_mode.settings.model
+        ) {
+          curModel = p.collaboration_mode.settings.model;
+        }
+
+        if (p.type !== 'token_count') continue;
+        const info = p.info || {};
+        const lt = info.last_token_usage;
+        if (!lt) continue;
+
+        const date = isoDay(d.timestamp);
+        if (!date) continue;
+
+        const inTok = num(lt.input_tokens);
+        const cached = num(lt.cached_input_tokens);
+        const outTok = num(lt.output_tokens);
+        const reasoning = num(lt.reasoning_output_tokens);
+
+        records.push({
+          tool: 'codex',
+          model: curModel,
+          date,
+          input: Math.max(0, inTok - cached),
+          output: Math.max(0, outTok - reasoning),
+          cacheCreate: 0,
+          cacheRead: cached,
+          reasoning,
+        });
+      }
+    }
+  }
+
+  return { tool: 'codex', sessionCount, records };
+}

package/src/aggregate.mjs

@@ -0,0 +1,72 @@
+// Merge raw adapter records into the publish payload shape:
+//   - models: one disjoint-bucket entry per (tool, model)
+//   - daily : per-day { codexTokens, claudeTokens } totals
+//   - firstDay / lastDay actually observed (after --since filtering)
+//
+// All inputs are numeric aggregates already — this module is pure arithmetic.
+
+/**
+ * @param {Array<{records:Array}>} adapterResults
+ * @param {{ since?: string|null }} opts  since = inclusive YYYY-MM-DD lower bound
+ */
+export function aggregate(adapterResults, { since = null } = {}) {
+  const modelMap = new Map(); // `${tool}|${model}` -> bucket
+  const dayMap = new Map(); // date -> { date, codexTokens, claudeTokens }
+  let firstDay = null;
+  let lastDay = null;
+
+  for (const result of adapterResults) {
+    for (const rec of result.records) {
+      if (since && rec.date < since) continue;
+
+      if (!firstDay || rec.date < firstDay) firstDay = rec.date;
+      if (!lastDay || rec.date > lastDay) lastDay = rec.date;
+
+      const key = `${rec.tool}|${rec.model}`;
+      let bucket = modelMap.get(key);
+      if (!bucket) {
+        bucket = {
+          model: rec.model,
+          tool: rec.tool,
+          input: 0,
+          output: 0,
+          cacheCreate: 0,
+          cacheRead: 0,
+          reasoning: 0,
+        };
+        modelMap.set(key, bucket);
+      }
+      bucket.input += rec.input;
+      bucket.output += rec.output;
+      bucket.cacheCreate += rec.cacheCreate;
+      bucket.cacheRead += rec.cacheRead;
+      bucket.reasoning += rec.reasoning;
+
+      const total =
+        rec.input + rec.output + rec.cacheCreate + rec.cacheRead + rec.reasoning;
+      let day = dayMap.get(rec.date);
+      if (!day) {
+        day = { date: rec.date, codexTokens: 0, claudeTokens: 0 };
+        dayMap.set(rec.date, day);
+      }
+      if (rec.tool === 'codex') day.codexTokens += total;
+      else day.claudeTokens += total;
+    }
+  }
+
+  const models = [...modelMap.values()].filter(
+    (m) =>
+      m.input + m.output + m.cacheCreate + m.cacheRead + m.reasoning > 0,
+  );
+  const daily = [...dayMap.values()].sort((a, b) =>
+    a.date < b.date ? -1 : a.date > b.date ? 1 : 0,
+  );
+
+  const totalTokens = models.reduce(
+    (s, m) =>
+      s + m.input + m.output + m.cacheCreate + m.cacheRead + m.reasoning,
+    0,
+  );
+
+  return { models, daily, firstDay, lastDay, totalTokens };
+}

package/src/pricing.mjs

@@ -0,0 +1,67 @@
+// Pricing factpack: fetch the authoritative per-million rates the server uses,
+// resolve a model id to its rates, and compute the API-equivalent $ with the
+// exact same formula the server applies — so the CLI preview equals the
+// published number.
+
+/** GET <apiBase>/api/tmx/pricing */
+export async function fetchPricing(apiBase) {
+  const res = await fetch(`${apiBase}/api/tmx/pricing`);
+  if (!res.ok) throw new Error(`pricing request failed: HTTP ${res.status}`);
+  return res.json();
+}
+
+/**
+ * Resolve a model id to its perMillion rates.
+ * Order: exact id -> alias -> longest prefix match (family heuristic) -> fallback.
+ */
+export function resolveRates(pricing, model) {
+  const id = String(model || '').toLowerCase();
+  const models = pricing.models || [];
+
+  for (const m of models) {
+    if (String(m.id).toLowerCase() === id) return m.perMillion;
+  }
+  for (const m of models) {
+    if ((m.aliases || []).some((a) => String(a).toLowerCase() === id)) {
+      return m.perMillion;
+    }
+  }
+  // Family heuristic: pick the model whose id/alias is the longest prefix of the
+  // requested id (e.g. "claude-opus-4-8-20990101" -> claude-opus-4-8). Longest
+  // wins so "gpt-5.5" never collapses to the shorter "gpt-5" alias of a mini.
+  let best = null;
+  let bestLen = -1;
+  for (const m of models) {
+    for (const cand of [m.id, ...(m.aliases || [])]) {
+      const c = String(cand).toLowerCase();
+      if (id.startsWith(c) && c.length > bestLen) {
+        best = m.perMillion;
+        bestLen = c.length;
+      }
+    }
+  }
+  if (best) return best;
+
+  return pricing.fallback;
+}
+
+/** costUsd for a single model's token buckets, matching the server formula. */
+export function costForModel(rates, tok) {
+  return (
+    (tok.input * rates.input +
+      tok.output * rates.output +
+      tok.cacheCreate * rates.cacheCreate +
+      tok.cacheRead * rates.cacheRead +
+      tok.reasoning * rates.reasoning) /
+    1e6
+  );
+}
+
+/** Sum costUsd across all aggregated model buckets. */
+export function previewCost(pricing, models) {
+  let usd = 0;
+  for (const m of models) {
+    usd += costForModel(resolveRates(pricing, m.model), m);
+  }
+  return usd;
+}

package/src/publish.mjs

@@ -0,0 +1,17 @@
+// Thin POST wrapper for /api/tmx/publish. Returns { status, json } and never
+// throws on non-2xx — the CLI decides how to present each documented reason.
+
+export async function publish(apiBase, body) {
+  const res = await fetch(`${apiBase}/api/tmx/publish`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  let json = null;
+  try {
+    json = await res.json();
+  } catch {
+    json = null;
+  }
+  return { status: res.status, json };
+}

package/src/secrets.mjs

@@ -0,0 +1,39 @@
+// Capability-token storage at ~/.config/tokenmax/<nick>.json.
+// The secret is the only credential that lets a nick be updated later. We store
+// it 0600 in a 0700 directory. No prompts, files, or keys ever go here.
+
+import os from 'node:os';
+import path from 'node:path';
+import { mkdir, readFile, writeFile, chmod } from 'node:fs/promises';
+
+function configDir() {
+  return path.join(os.homedir(), '.config', 'tokenmax');
+}
+
+function secretFile(nick) {
+  return path.join(configDir(), `${nick}.json`);
+}
+
+/** Return the saved secret for nick, or null if none/unreadable. */
+export async function loadSecret(nick) {
+  try {
+    const text = await readFile(secretFile(nick), 'utf8');
+    const data = JSON.parse(text);
+    return typeof data.secret === 'string' && data.secret ? data.secret : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Persist { nick, secret, url, createdAt } with restrictive permissions.
+ * @returns absolute path written
+ */
+export async function saveSecret(nick, data) {
+  await mkdir(configDir(), { recursive: true, mode: 0o700 });
+  const file = secretFile(nick);
+  await writeFile(file, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+  // mkdir/writeFile mode is umask-masked; force the bits explicitly.
+  await chmod(file, 0o600).catch(() => {});
+  return file;
+}

package/src/util.mjs

@@ -0,0 +1,46 @@
+// Shared, dependency-free helpers used by the adapters and aggregator.
+// SAFETY: nothing here ever touches prompt text, file contents, or keys —
+// only numbers, model id strings, and ISO timestamps.
+
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+
+/** Coerce any value into a finite, non-negative integer token count. */
+export function num(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return Math.round(n);
+}
+
+/** Extract the YYYY-MM-DD day from an ISO timestamp, or null if unusable. */
+export function isoDay(ts) {
+  if (typeof ts !== 'string' || ts.length < 10) return null;
+  const day = ts.slice(0, 10);
+  return /^\d{4}-\d{2}-\d{2}$/.test(day) ? day : null;
+}
+
+/** Recursively yield every *.jsonl file under dir (missing dir => nothing). */
+export async function* walkJsonl(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const e of entries) {
+    const p = path.join(dir, e.name);
+    if (e.isDirectory()) {
+      yield* walkJsonl(p);
+    } else if (e.isFile() && e.name.endsWith('.jsonl')) {
+      yield p;
+    }
+  }
+}
+
+/** Iterate non-empty trimmed lines of a string. */
+export function* lines(text) {
+  for (const line of text.split('\n')) {
+    const t = line.trim();
+    if (t) yield t;
+  }
+}