tokentracker-cli 0.97.2 → 0.99.0

package/src/lib/heatmap-compact.js

@@ -0,0 +1,114 @@
+"use strict";
+
+// Expand the `format=compact` activity-heatmap payload back into the schema the
+// dashboard, popover and widget already render.
+//
+// The heatmap is the single largest cloud read we serve: 2.55 GB/day on
+// 2026-09-21, 31% of all egress, and 94% of it proxied through this CLI. The
+// bytes were never the data — `account_heatmap_compact` hands the edge ~12 KB
+// of sparse rows, and the edge blew that up to ~42 KB by materialising a
+// 52-week × 7-day grid of five-key objects, where `billable_total_tokens`
+// simply repeats `total_tokens` and `level` is derived from the window maximum.
+//
+// So the grid gets rebuilt here instead, one hop later, off the same sparse
+// rows. The rendered payload is identical; it just stops crossing the network.
+//
+// Model names are the other half of it. A year of daily rows repeats the same
+// ~160 names ~1900 times, which was 57% of even the sparse payload, so they are
+// sent once in `model_names` and referenced by index from flat
+// [index, tokens, index, tokens, ...] pairs.
+//
+// This mirrors the tail of dashboard/edge-patches/tokentracker-account-heatmap.ts
+// step for step, including the details that look incidental but are not:
+// coercion through Number(), last-row-wins on a repeated day, and `{}` (not
+// null) for a present row whose models map is empty.
+
+/** Next YYYY-MM-DD, treating the key as a UTC calendar day (same as the edge). */
+function nextDayKey(dayKey) {
+  const d = new Date(`${dayKey}T00:00:00Z`);
+  d.setUTCDate(d.getUTCDate() + 1);
+  return d.toISOString().slice(0, 10);
+}
+
+const DAY_KEY_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+// 104 weeks is the edge's own `weeks` clamp; the guard is here so a malformed
+// `to` cannot spin the grid loop forever.
+const MAX_GRID_DAYS = 104 * 7 + 7;
+
+/**
+ * @param {unknown} payload a `tokentracker-account-heatmap` response.
+ * @returns {unknown} the dense payload, or `payload` itself when it is not a
+ *   well-formed compact response — which is also how a new CLI stays correct
+ *   against an edge that predates the compact branch.
+ */
+function expandHeatmapCompact(payload) {
+  if (!payload || typeof payload !== "object") return payload;
+  if (payload.format !== "compact") return payload;
+  if (!Array.isArray(payload.days)) return payload;
+  // Without the dictionary the indices resolve to nothing and every model
+  // breakdown would render empty, so refuse the payload instead of silently
+  // dropping data.
+  if (!Array.isArray(payload.model_names)) return payload;
+  if (!DAY_KEY_RE.test(String(payload.from)) || !DAY_KEY_RE.test(String(payload.to))) return payload;
+
+  const names = payload.model_names;
+  const byDay = new Map();
+  for (const row of payload.days) {
+    if (!Array.isArray(row)) continue;
+    const [day, total, pairs] = row;
+    if (!DAY_KEY_RE.test(String(day))) continue;
+    const mdl = {};
+    if (Array.isArray(pairs)) {
+      // `i + 1 < length` drops a trailing index with no value rather than
+      // recording it as 0.
+      for (let i = 0; i + 1 < pairs.length; i += 2) {
+        const name = names[pairs[i]];
+        if (typeof name === "string") mdl[name] = Number(pairs[i + 1]) || 0;
+      }
+    }
+    // Last row wins, as Map.set did on the edge.
+    byDay.set(String(day), { total: Number(total) || 0, models: mdl });
+  }
+
+  const maxValue = Number(payload.max_value) || 0;
+  const levelOf = (v) => {
+    if (v <= 0) return 0;
+    if (maxValue === 0) return 1;
+    const r = v / maxValue;
+    if (r <= 0.25) return 1;
+    if (r <= 0.5) return 2;
+    if (r <= 0.75) return 3;
+    return 4;
+  };
+
+  const cells = [];
+  const to = String(payload.to);
+  let cursor = String(payload.from);
+  while (cursor <= to && cells.length < MAX_GRID_DAYS) {
+    const hit = byDay.get(cursor);
+    const total = hit ? hit.total : 0;
+    cells.push({
+      day: cursor,
+      total_tokens: total,
+      billable_total_tokens: total,
+      level: levelOf(total),
+      models: hit ? hit.models : null,
+    });
+    cursor = nextDayKey(cursor);
+  }
+
+  const weeks = [];
+  for (let i = 0; i < cells.length; i += 7) weeks.push(cells.slice(i, i + 7));
+
+  return {
+    from: payload.from,
+    to: payload.to,
+    week_starts_on: payload.week_starts_on,
+    active_days: payload.active_days,
+    streak_days: payload.streak_days,
+    weeks,
+  };
+}
+
+module.exports = { expandHeatmapCompact };

package/src/lib/local-api.js

@@ -2380,20 +2380,21 @@ function createLocalApiHandler({ queuePath }) {
         ma.totals.cached_input_tokens += row.cached_input_tokens || 0;
         ma.totals.cache_creation_input_tokens += row.cache_creation_input_tokens || 0;
         ma.totals.reasoning_output_tokens += row.reasoning_output_tokens || 0;
-        ma.totals.total_cost_usd = Number(ma.totals.total_cost_usd || 0)
-          + (Number(row.total_cost_usd) || 0);
+        // Price each row, exactly as aggregateByDay does for the hero (#653).
+        // computeRowCost is not linear for models with a Fast tier or
+        // long-context rates: priority_* / long_context_* mark a subset of the
+        // base columns rather than adding volume, so they survive only while the
+        // row is intact. Summing the base columns first and pricing once silently
+        // dropped every premium — same tokens, fewer dollars than the hero.
+        ma.totals.total_cost_usd = Number(ma.totals.total_cost_usd || 0) + computeRowCost(row);
       }
 
       const sources = Array.from(bySource.values()).map((s) => {
         s.models = Array.from(s.models.values())
-          .map((m) => {
-            const cost = computeRowCost({
-              ...m.totals,
-              model: m.model,
-              source: s.source,
-            });
-            return { ...m, totals: { ...m.totals, total_cost_usd: cost.toFixed(6) } };
-          })
+          .map((m) => ({
+            ...m,
+            totals: { ...m.totals, total_cost_usd: Number(m.totals.total_cost_usd || 0).toFixed(6) },
+          }))
           .sort((a, b) => b.totals.total_tokens - a.totals.total_tokens);
         const sourceCost = s.models.reduce((sum, m) => sum + Number(m.totals.total_cost_usd), 0);
         s.totals.total_cost_usd = sourceCost.toFixed(6);

package/src/lib/opencode-config.js

@@ -26,7 +26,7 @@ function buildOpencodePlugin({ notifyPath }) {
   return (
     `// ${PLUGIN_MARKER}\n` +
     `const notifyPath = ${JSON.stringify(safeNotifyPath)};\n` +
-    `export const TokenTrackerPlugin = async ({ $ }) => {\n` +
+    `const server = async ({ $ }) => {\n` +
     `  return {\n` +
     `    event: async ({ event }) => {\n` +
     `      if (!event || event.type !== ${JSON.stringify(DEFAULT_EVENT)}) return;\n` +
@@ -40,6 +40,25 @@ function buildOpencodePlugin({ notifyPath }) {
     `      } catch (_) {}\n` +
     `    }\n` +
     `  };\n` +
+    `};\n` +
+    // Three loaders read this one file (issue #646):
+    //   * older opencode v1 takes the named export;
+    //   * current v1 (verified on 1.18.30) requires a default export carrying
+    //     `id` and `server()`, and rejects the file outright without them;
+    //   * v2 requires a default export carrying `id` and `setup()`/`effect()`,
+    //     and ignores `server()`.
+    // Emitting all three keeps a single generated file valid everywhere. v2's
+    // plugin context exposes no event stream and no shell (`@opencode-ai/plugin`
+    // v2 PluginContext is agent/aisdk/catalog/command/integration/reference/skill
+    // only), so there is nothing for `setup` to subscribe to -- it exists to make
+    // the plugin load instead of erroring on every startup. Usage itself does not
+    // depend on this hook: opencode rows are parsed from the on-disk storage and
+    // opencode.db, and the hook only makes a sync happen sooner.
+    `export const TokenTrackerPlugin = server;\n` +
+    `export default {\n` +
+    `  id: "tokentracker",\n` +
+    `  server,\n` +
+    `  setup: async () => {},\n` +
     `};\n`
   );
 }

package/src/lib/pricing/curated-overrides.json

@@ -159,6 +159,20 @@
       "cache_read": 0.014,
       "cache_write": 0.44
     },
+    "deepseek-v4.1-flash": {
+      "input": 0.3,
+      "output": 1.2,
+      "cache_read": 0.006,
+      "cache_write": 0.3,
+      "note": "DeepSeek V4.1 Flash (official API id deepseek-flash, released 2026-09-10). deepseek-v4.1-flash is the id reported by OpenRouter, Command Code and WorkBuddy. Peak rates per https://api-docs.deepseek.com/quick_start/pricing/ ($0.30 / $1.20 / $0.006 cache read per MTok); computeRowCost halves them off-peak like the other DeepSeek V4 entries."
+    },
+    "deepseek-flash": {
+      "input": 0.3,
+      "output": 1.2,
+      "cache_read": 0.006,
+      "cache_write": 0.3,
+      "note": "Official DeepSeek API id for DeepSeek-V4.1-Flash. Same rates as deepseek-v4.1-flash."
+    },
     "deepseek-chat": {
       "input": 0.14,
       "output": 0.28,
@@ -544,6 +558,14 @@
       "match": "minimax-m2.7",
       "ref": "MiniMax-M2.7"
     },
+    {
+      "match": "deepseek-v4.1-flash",
+      "ref": "deepseek-v4.1-flash"
+    },
+    {
+      "match": "deepseek-flash",
+      "ref": "deepseek-flash"
+    },
     {
       "match": "deepseek-v4-flash",
       "ref": "deepseek-v4-flash"

package/src/lib/pricing/index.js

@@ -33,6 +33,8 @@ const SOURCES_WITH_AUTHORITATIVE_COST = new Set(["grok"]);
 const SEED_SNAPSHOT_PATH = path.resolve(__dirname, "seed-snapshot.json");
 const DEEPSEEK_TIME_PRICED_MODELS = [
   "deepseek-v4-flash",
+  "deepseek-v4.1-flash",
+  "deepseek-flash",
   "deepseek-v4-pro",
 ];
 // Sync seed load. Done at require-time so callers that haven't awaited