codexmeter 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexmeter",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Local telemetry dashboard for Codex CLI usage",
   "type": "module",
   "bin": {

package/server/aggregator.js

@@ -240,7 +240,10 @@ function buildDaily(rawSessions, groupedSessions, tz) {
     const startDay = toDayKeyInTz(startMs);
     const endDay = toDayKeyInTz(endMs - 1);
 
-    if (startDay === endDay) {
+    if (s.has_usage_by_day) {
+      addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKeyInTz, s);
+      addUsageByDay(dayMap, s);
+    } else if (startDay === endDay) {
       addToDay(dayMap, startDay, s, 1.0);
     } else {
       let cursor = dayStartMs(startDay);
@@ -314,12 +317,25 @@ function buildHeatmap(rawSessions, groupedSessions, tz) {
   const dayMap = new Map();
   for (const s of rawSessions) {
     if (!s.started_at) continue;
-    const dk = toDayKeyInTz(s.started_at * 1000);
-    if (!dayMap.has(dk)) dayMap.set(dk, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
-    const d = dayMap.get(dk);
-    d.tokens += s.tokens_used;
-    if (s.cost !== null) d.cost += s.cost;
-    d.sessions++;
+    if (s.has_usage_by_day) {
+      for (const usageDay of s.usage_by_day || []) {
+        const dayKey = usageDay.day;
+        if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+        const d = dayMap.get(dayKey);
+        d.tokens += usageDay.tokens || 0;
+        if (usageDay.cost !== null) d.cost += usageDay.cost;
+      }
+      const startDay = toDayKeyInTz(s.started_at * 1000);
+      if (!dayMap.has(startDay)) dayMap.set(startDay, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+      dayMap.get(startDay).sessions++;
+    } else {
+      const dk = toDayKeyInTz(s.started_at * 1000);
+      if (!dayMap.has(dk)) dayMap.set(dk, { tokens: 0, cost: 0, elapsed: 0, sessions: 0 });
+      const d = dayMap.get(dk);
+      d.tokens += s.tokens_used;
+      if (s.cost !== null) d.cost += s.cost;
+      d.sessions++;
+    }
   }
 
   for (const s of groupedSessions) {
@@ -332,6 +348,62 @@ function buildHeatmap(rawSessions, groupedSessions, tz) {
   return Object.fromEntries(dayMap);
 }
 
+function addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKeyInTz, session) {
+  if (startDay === endDay) {
+    addPresenceToDay(dayMap, startDay, session, 1.0);
+    return;
+  }
+
+  let cursor = dayStartMs(startDay);
+  while (cursor < endMs) {
+    const nextDay = cursor + 86400000;
+    const overlapStart = Math.max(cursor, startMs);
+    const overlapEnd = Math.min(nextDay, endMs);
+    const fraction = (overlapEnd - overlapStart) / totalDur;
+    if (fraction > 0) addPresenceToDay(dayMap, toDayKeyInTz(cursor), session, fraction);
+    cursor = nextDay;
+  }
+}
+
+function addPresenceToDay(dayMap, dayKey, session, fraction) {
+  if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
+  const d = dayMap.get(dayKey);
+  if (fraction > 0.001) d.sessions++;
+
+  const fKey = session.agent_family;
+  if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, sessions: 0 };
+  if (fraction > 0.001) d.by_family[fKey].sessions++;
+
+  const rKey = session.repo_label || 'unknown';
+  if (!d.by_repo[rKey]) d.by_repo[rKey] = { tokens: 0, cost: 0, sessions: 0 };
+  if (fraction > 0.001) d.by_repo[rKey].sessions++;
+}
+
+function addUsageByDay(dayMap, session) {
+  for (const usageDay of session.usage_by_day || []) {
+    const dayKey = usageDay.day;
+    if (!dayMap.has(dayKey)) dayMap.set(dayKey, { tokens: 0, cost: 0, elapsed_seconds: 0, sessions: 0, by_model: {}, by_family: {}, by_repo: {} });
+    const d = dayMap.get(dayKey);
+    d.tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.cost += usageDay.cost;
+
+    const mKey = session.model_name || 'unknown';
+    if (!d.by_model[mKey]) d.by_model[mKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+    d.by_model[mKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.by_model[mKey].cost += usageDay.cost;
+
+    const fKey = session.agent_family;
+    if (!d.by_family[fKey]) d.by_family[fKey] = { tokens: 0, cost: 0, sessions: 0 };
+    d.by_family[fKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.by_family[fKey].cost += usageDay.cost;
+
+    const rKey = session.repo_label || 'unknown';
+    if (!d.by_repo[rKey]) d.by_repo[rKey] = { tokens: 0, cost: 0, sessions: 0 };
+    d.by_repo[rKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) d.by_repo[rKey].cost += usageDay.cost;
+  }
+}
+
 function dayStartMs(dayKey) {
   const [y, m, d] = dayKey.split('-').map(Number);
   return new Date(y, m - 1, d).getTime();

package/server/cost-catalog.js

@@ -32,7 +32,7 @@ export function getCacheAwareRate(modelName) {
   return INPUT_FRACTION * effectiveInputRate + OUTPUT_FRACTION * entry.output;
 }
 
-function calculateCostFromUsage(modelName, usage) {
+export function calculateCostFromUsage(modelName, usage) {
   if (!modelName || !usage) return null;
   const entry = getPricing()[modelName];
   if (!entry) return null;

package/server/ingest.js

@@ -4,7 +4,7 @@ import {
   normalizeCwd, deriveRepoKey, deriveRepoLabel,
   classifyAgentFamily, isSubagent, normalizeModelName,
 } from './normalize.js';
-import { initPricing, priceSession } from './cost-catalog.js';
+import { calculateCostFromUsage, initPricing, priceSession } from './cost-catalog.js';
 import { buildAggregates, buildSessionView } from './aggregator.js';
 import { createDayKeyFormatter } from './day-key.js';
 import { createLiveAggregateState, createEmptyLivePatch, applySessionToLiveState, buildLiveBootstrap, buildLivePatch } from './live-state.js';
@@ -98,6 +98,8 @@ export async function runIngest(codexHome, state, opts = {}) {
         model_name: null,
         reasoning_effort: null,
         usage_total: null,
+        usage_by_day: null,
+        has_usage_by_day: false,
         active_by_day: null,
         agent_role: t.agent_role,
         agent_nickname: t.agent_nickname,
@@ -160,6 +162,10 @@ export async function runIngest(codexHome, state, opts = {}) {
           if (data.reasoning_effort) s.reasoning_effort = data.reasoning_effort;
           if (data.parent_thread_id) s.parent_thread_id = data.parent_thread_id;
           if (data.usage_total) s.usage_total = data.usage_total;
+          if (data.usage_by_day) {
+            s.usage_by_day = buildUsageByDayMetrics(s.model_name, data.usage_by_day);
+            s.has_usage_by_day = s.usage_by_day.length > 0;
+          }
           if (data.active_seconds && data.active_seconds > 0) {
             s.elapsed_seconds = data.active_seconds;
             s.active_by_day = data.active_by_day || null;
@@ -352,6 +358,21 @@ function finalizeSessionMetrics(session, toDayKey) {
   }
 }
 
+function buildUsageByDayMetrics(modelName, usageByDay) {
+  const entries = [];
+  for (const [dayKey, usage] of Object.entries(usageByDay || {})) {
+    const tokens = (usage?.input_tokens || 0) + (usage?.output_tokens || 0);
+    const cost = calculateCostFromUsage(modelName, usage);
+    entries.push({
+      day: dayKey,
+      tokens,
+      cost,
+    });
+  }
+  entries.sort((a, b) => a.day.localeCompare(b.day));
+  return entries;
+}
+
 function queueLiveProgress(state) {
   state.live_progress_dirty = true;
   ensureLivePump(state);

package/server/live-state.js

@@ -217,7 +217,10 @@ function applyDailyBucket(dayMap, session, toDayKey, dirtySet) {
     const startDay = toDayKey(startMs);
     const endDay = toDayKey(endMs - 1);
 
-    if (startDay === endDay) {
+    if (session.has_usage_by_day) {
+      addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKey, session, dirtySet);
+      addUsageByDay(dayMap, session, dirtySet);
+    } else if (startDay === endDay) {
       addToDay(dayMap, startDay, session, 1.0);
       dirtySet.add(startDay);
     } else {
@@ -247,7 +250,21 @@ function applyDailyBucket(dayMap, session, toDayKey, dirtySet) {
 }
 
 function applyHeatmapBucket(dayMap, session, toDayKey, dirtySet) {
-  if (session.started_at) {
+  if (session.has_usage_by_day) {
+    for (const usageDay of session.usage_by_day || []) {
+      const dayKey = usageDay.day;
+      const day = ensureHeatmapDay(dayMap, dayKey);
+      day.tokens += usageDay.tokens || 0;
+      if (usageDay.cost !== null) day.cost += usageDay.cost;
+      dirtySet.add(dayKey);
+    }
+    if (session.started_at) {
+      const startDay = toDayKey(session.started_at * 1000);
+      const day = ensureHeatmapDay(dayMap, startDay);
+      day.sessions += 1;
+      dirtySet.add(startDay);
+    }
+  } else if (session.started_at) {
     const dayKey = toDayKey(session.started_at * 1000);
     const day = ensureHeatmapDay(dayMap, dayKey);
     day.tokens += session.tokens_used || 0;
@@ -265,6 +282,48 @@ function applyHeatmapBucket(dayMap, session, toDayKey, dirtySet) {
   }
 }
 
+function addSessionPresence(dayMap, startDay, endDay, startMs, endMs, totalDur, toDayKey, session, dirtySet) {
+  if (startDay === endDay) {
+    addPresenceToDay(dayMap, startDay, session, 1.0);
+    dirtySet.add(startDay);
+    return;
+  }
+
+  let cursor = dayStartMs(startDay);
+  while (cursor < endMs) {
+    const nextDay = cursor + 86400000;
+    const overlapStart = Math.max(cursor, startMs);
+    const overlapEnd = Math.min(nextDay, endMs);
+    const fraction = (overlapEnd - overlapStart) / totalDur;
+    if (fraction > 0) {
+      const dayKey = toDayKey(cursor);
+      addPresenceToDay(dayMap, dayKey, session, fraction);
+      dirtySet.add(dayKey);
+    }
+    cursor = nextDay;
+  }
+}
+
+function addPresenceToDay(dayMap, dayKey, session, fraction) {
+  const day = ensureDay(dayMap, dayKey);
+  if (fraction > 0.001) day.sessions += 1;
+}
+
+function addUsageByDay(dayMap, session, dirtySet) {
+  for (const usageDay of session.usage_by_day || []) {
+    const dayKey = usageDay.day;
+    const day = ensureDay(dayMap, dayKey);
+    day.tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) day.cost += usageDay.cost;
+
+    const modelKey = session.model_name || 'unknown';
+    if (!day.by_model[modelKey]) day.by_model[modelKey] = { tokens: 0, cost: 0, elapsed_seconds: 0 };
+    day.by_model[modelKey].tokens += usageDay.tokens || 0;
+    if (usageDay.cost !== null) day.by_model[modelKey].cost += usageDay.cost;
+    dirtySet.add(dayKey);
+  }
+}
+
 function addToDay(dayMap, dayKey, session, fraction) {
   const day = ensureDay(dayMap, dayKey);
   day.tokens += (session.tokens_used || 0) * fraction;

package/server/rollout-reader.js

@@ -18,6 +18,7 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     last_timestamp: null,
     active_seconds: null,
     active_by_day: null,
+    usage_by_day: null,
     parent_thread_id: null,
     usage_total: null,
   };
@@ -28,6 +29,11 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
     let prevTimestamp = null;
     let activeMs = 0;
     const activeByDay = new Map();
+    const usageByDay = new Map();
+    let lastInputTokens = 0;
+    let lastCachedInputTokens = 0;
+    let lastOutputTokens = 0;
+    let hasSeenUsage = false;
     for (const line of content.split(/\r?\n/)) {
       if (!line.trim()) continue;
 
@@ -58,13 +64,43 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
         if (obj.type === 'event_msg' && obj.payload?.type === 'token_count') {
           const usage = obj.payload.info?.total_token_usage;
           if (usage) {
+            const inputTokens = usage.input_tokens || 0;
+            const cachedInputTokens = usage.cached_input_tokens || 0;
+            const outputTokens = usage.output_tokens || 0;
+            const reasoningOutputTokens = usage.reasoning_output_tokens || 0;
+            const totalTokens = usage.total_tokens || 0;
+
             result.usage_total = {
-              input_tokens: usage.input_tokens || 0,
-              cached_input_tokens: usage.cached_input_tokens || 0,
-              output_tokens: usage.output_tokens || 0,
-              reasoning_output_tokens: usage.reasoning_output_tokens || 0,
-              total_tokens: usage.total_tokens || 0,
+              input_tokens: inputTokens,
+              cached_input_tokens: cachedInputTokens,
+              output_tokens: outputTokens,
+              reasoning_output_tokens: reasoningOutputTokens,
+              total_tokens: totalTokens,
             };
+
+            const usageDelta = hasSeenUsage
+              ? {
+                  input_tokens: Math.max(inputTokens - lastInputTokens, 0),
+                  cached_input_tokens: Math.max(cachedInputTokens - lastCachedInputTokens, 0),
+                  output_tokens: Math.max(outputTokens - lastOutputTokens, 0),
+                }
+              : {
+                  input_tokens: inputTokens,
+                  cached_input_tokens: cachedInputTokens,
+                  output_tokens: outputTokens,
+                };
+
+            hasSeenUsage = true;
+            lastInputTokens = inputTokens;
+            lastCachedInputTokens = cachedInputTokens;
+            lastOutputTokens = outputTokens;
+            if (obj.timestamp && hasUsage(usageDelta)) {
+              const ts = new Date(obj.timestamp).getTime();
+              if (!isNaN(ts)) {
+                const dayKey = toDayKey(ts);
+                mergeUsageTotals(usageByDay, dayKey, usageDelta);
+              }
+            }
           }
         }
 
@@ -100,9 +136,51 @@ export async function enrichFromRollout(rolloutPath, opts = {}) {
       result.active_by_day = activeByDaySeconds;
       result.active_seconds = Object.values(activeByDaySeconds).reduce((sum, seconds) => sum + seconds, 0);
     }
+    if (usageByDay.size > 0) {
+      result.usage_by_day = Object.fromEntries(usageByDay);
+    }
   } catch {
     return null;
   }
 
   return result;
 }
+
+function normalizeUsageTotals(usage) {
+  return {
+    input_tokens: usage.input_tokens || 0,
+    cached_input_tokens: usage.cached_input_tokens || 0,
+    output_tokens: usage.output_tokens || 0,
+    reasoning_output_tokens: usage.reasoning_output_tokens || 0,
+    total_tokens: usage.total_tokens || 0,
+  };
+}
+
+function subtractUsageTotals(current, previous) {
+  return {
+    input_tokens: Math.max((current.input_tokens || 0) - (previous.input_tokens || 0), 0),
+    cached_input_tokens: Math.max((current.cached_input_tokens || 0) - (previous.cached_input_tokens || 0), 0),
+    output_tokens: Math.max((current.output_tokens || 0) - (previous.output_tokens || 0), 0),
+    reasoning_output_tokens: Math.max((current.reasoning_output_tokens || 0) - (previous.reasoning_output_tokens || 0), 0),
+    total_tokens: Math.max((current.total_tokens || 0) - (previous.total_tokens || 0), 0),
+  };
+}
+
+function hasUsage(usage) {
+  return !!usage && (
+    usage.input_tokens > 0 ||
+    usage.cached_input_tokens > 0 ||
+    usage.output_tokens > 0
+  );
+}
+
+function mergeUsageTotals(target, dayKey, usage) {
+  let previous = target.get(dayKey);
+  if (!previous) {
+    previous = { input_tokens: 0, cached_input_tokens: 0, output_tokens: 0 };
+    target.set(dayKey, previous);
+  }
+  previous.input_tokens += usage.input_tokens || 0;
+  previous.cached_input_tokens += usage.cached_input_tokens || 0;
+  previous.output_tokens += usage.output_tokens || 0;
+}