tokens-metric 0.4.2 → 0.4.3

package/dist/core/detect.js

@@ -8,6 +8,12 @@ export function claudeHome() {
 export function claudeConfigPath() {
     return join(homedir(), '.claude.json');
 }
+export function codexHome() {
+    return join(homedir(), '.codex');
+}
+export function codexSessionsDir() {
+    return join(codexHome(), 'sessions');
+}
 /**
  * Detect whether Claude Code is installed, the user is logged in, and best-
  * effort what plan they're on. All signals are LOCAL and BEST-EFFORT — we

package/dist/core/format.js

@@ -17,15 +17,37 @@ const PRICES_PER_MTOK = {
     'claude-opus-4': { in: 15, out: 75, cacheWrite: 18.75, cacheRead: 1.5 },
     // Haiku 4.x family
     'claude-haiku-4': { in: 0.8, out: 4, cacheWrite: 1, cacheRead: 0.08 },
+    // OpenAI o4-mini — default Codex CLI model; also used for "codex" key
+    'openai-o4-mini': { in: 1.1, out: 4.4, cacheWrite: 0, cacheRead: 0.275 },
+    // OpenAI o3
+    'openai-o3': { in: 10, out: 40, cacheWrite: 0, cacheRead: 2.5 },
+    // OpenAI o3-mini
+    'openai-o3-mini': { in: 1.1, out: 4.4, cacheWrite: 0, cacheRead: 0.275 },
+    // OpenAI GPT-4o
+    'openai-gpt-4o': { in: 2.5, out: 10, cacheWrite: 0, cacheRead: 1.25 },
+    // OpenAI GPT-4o mini
+    'openai-gpt-4o-mini': { in: 0.15, out: 0.6, cacheWrite: 0, cacheRead: 0.075 },
 };
 function priceKey(model) {
     const m = model.toLowerCase();
+    // Claude
     if (m.includes('opus'))
         return 'claude-opus-4';
     if (m.includes('haiku'))
         return 'claude-haiku-4';
     if (m.includes('sonnet'))
         return 'claude-sonnet-4';
+    // OpenAI / Codex — "codex" key maps to o4-mini (Codex CLI default)
+    if (m === 'codex' || m.includes('o4-mini'))
+        return 'openai-o4-mini';
+    if (m.includes('o3-mini'))
+        return 'openai-o3-mini';
+    if (m === 'o3' || m.endsWith('-o3'))
+        return 'openai-o3';
+    if (m.includes('gpt-4o-mini'))
+        return 'openai-gpt-4o-mini';
+    if (m.includes('gpt-4o'))
+        return 'openai-gpt-4o';
     return null;
 }
 export function estimateCostUSD(model, u) {

package/dist/core/history.js

@@ -1,7 +1,7 @@
 import { readdirSync, statSync, createReadStream, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { claudeHome } from './detect.js';
+import { claudeHome, codexSessionsDir } from './detect.js';
 import { addUsage, EMPTY_USAGE, totalTokens } from './types.js';
 import { estimateCostUSD } from './format.js';
 import { loadStore, replaceDayIn, saveStore, } from './history-store.js';
@@ -10,16 +10,21 @@ let storedDays = null;
 export async function buildHistory(now = Date.now()) {
     if (storedDays === null)
         storedDays = loadStore();
-    const root = join(claudeHome(), 'projects');
-    if (!existsSync(root)) {
-        // No transcripts available; surface whatever the store has.
+    const claudeRoot = join(claudeHome(), 'projects');
+    const codexRoot = codexSessionsDir();
+    const allFiles = [];
+    if (existsSync(claudeRoot))
+        allFiles.push(...listAllJsonl(claudeRoot));
+    if (existsSync(codexRoot))
+        allFiles.push(...listCodexJsonl(codexRoot));
+    if (allFiles.length === 0)
         return aggregate(now);
-    }
-    const files = listAllJsonl(root);
-    for (const f of files) {
+    for (const f of allFiles) {
         const cached = cache.get(f.path);
         if (!cached || cached.mtimeMs < f.mtimeMs) {
-            const parsed = await parseFile(f.path);
+            const parsed = f.path.includes('/.codex/sessions/')
+                ? await parseCodexFile(f.path)
+                : await parseFile(f.path);
             cache.set(f.path, {
                 mtimeMs: f.mtimeMs,
                 byDay: parsed.byDay,
@@ -30,7 +35,7 @@ export async function buildHistory(now = Date.now()) {
             });
         }
     }
-    const known = new Set(files.map((f) => f.path));
+    const known = new Set(allFiles.map((f) => f.path));
     for (const key of Array.from(cache.keys())) {
         if (!known.has(key))
             cache.delete(key);
@@ -245,6 +250,83 @@ async function parseFile(path) {
 function numberOr0(v) {
     return typeof v === 'number' && Number.isFinite(v) ? v : 0;
 }
+function listCodexJsonl(root) {
+    const out = [];
+    for (const year of safeReaddir(root)) {
+        for (const month of safeReaddir(join(root, year))) {
+            for (const day of safeReaddir(join(root, year, month))) {
+                const dayDir = join(root, year, month, day);
+                for (const f of safeReaddir(dayDir)) {
+                    if (!f.endsWith('.jsonl'))
+                        continue;
+                    const p = join(dayDir, f);
+                    try {
+                        const s = statSync(p);
+                        out.push({ path: p, mtimeMs: s.mtimeMs });
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+    return out;
+}
+async function parseCodexFile(path) {
+    const byDay = new Map();
+    const sessionId = (path.split('/').pop() ?? path).replace(/\.jsonl$/, '');
+    let earliestEventMs = null;
+    let latestEventMs = null;
+    let cwd;
+    const stream = createReadStream(path, { encoding: 'utf8' });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let evt;
+        try {
+            evt = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (evt?.type === 'session_meta' && typeof evt?.payload?.cwd === 'string') {
+            if (!cwd)
+                cwd = evt.payload.cwd;
+        }
+        const ts = typeof evt?.timestamp === 'string' ? Date.parse(evt.timestamp) : NaN;
+        if (Number.isFinite(ts)) {
+            if (earliestEventMs === null || ts < earliestEventMs)
+                earliestEventMs = ts;
+            if (latestEventMs === null || ts > latestEventMs)
+                latestEventMs = ts;
+        }
+        if (evt?.type !== 'event_msg')
+            continue;
+        if (evt?.payload?.type !== 'token_count')
+            continue;
+        const info = evt?.payload?.info;
+        if (!info)
+            continue;
+        const last = info.last_token_usage;
+        if (!last)
+            continue;
+        if (!Number.isFinite(ts))
+            continue;
+        const day = startOfDay(ts);
+        const u = {
+            input_tokens: numberOr0(last.input_tokens),
+            output_tokens: numberOr0(last.output_tokens) + numberOr0(last.reasoning_output_tokens),
+            cache_read_input_tokens: numberOr0(last.cached_input_tokens),
+            cache_creation_input_tokens: 0,
+        };
+        const bucket = byDay.get(day) ?? {};
+        bucket['codex'] = addUsage(bucket['codex'] ?? EMPTY_USAGE(), u);
+        byDay.set(day, bucket);
+    }
+    return { byDay, sessionId, earliestEventMs, latestEventMs, cwd };
+}
 /**
  * Returns all sessions (transcripts) that had activity today, sorted by
  * start time descending (most recent first). Marks the active one.

package/dist/core/parser.js

@@ -1,7 +1,7 @@
 import { readdirSync, statSync, createReadStream, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { claudeHome } from './detect.js';
+import { claudeHome, codexSessionsDir } from './detect.js';
 import { addUsage, EMPTY_USAGE, } from './types.js';
 const PROJECTS_DIR = () => join(claudeHome(), 'projects');
 /**
@@ -142,3 +142,133 @@ function parseTimestamp(v) {
     const n = Date.parse(v);
     return Number.isFinite(n) ? n : undefined;
 }
+/**
+ * Aggregate a transcript using the appropriate parser (auto-detected by path).
+ */
+export async function aggregateAnyTranscript(path) {
+    if (path.includes('/.codex/sessions/')) {
+        const stats = {
+            sessionId: deriveSessionId(path),
+            transcriptPath: path,
+            totals: EMPTY_USAGE(),
+            byModel: {},
+            messageCount: 0,
+            lastMsgUsage: null,
+        };
+        const stream = (await import('node:fs')).createReadStream(path, { encoding: 'utf8' });
+        const rl = (await import('node:readline')).createInterface({ input: stream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (line.trim())
+                applyCodexLine(stats, line);
+        }
+        return stats;
+    }
+    return aggregateTranscript(path);
+}
+/**
+ * Returns the most recently active transcript across Claude Code and Codex CLI,
+ * or null if neither has a session within the window.
+ */
+export function findMostRecentActiveTranscript(withinMs = 5 * 60_000) {
+    const claude = findActiveTranscript(withinMs);
+    const codex = findActiveCodexTranscript(withinMs);
+    if (!claude && !codex)
+        return null;
+    if (!claude)
+        return codex;
+    if (!codex)
+        return claude;
+    // Both exist — pick the one with the most recent file
+    const claudeMtime = listTranscripts()[0]?.mtimeMs ?? 0;
+    const codexMtime = listCodexTranscripts()[0]?.mtimeMs ?? 0;
+    return codexMtime > claudeMtime ? codex : claude;
+}
+// ─── Codex CLI support ────────────────────────────────────────────────────────
+const CODEX_SESSIONS_DIR = () => codexSessionsDir();
+/**
+ * Walk ~/.codex/sessions/YYYY/MM/DD/*.jsonl and return transcript files
+ * sorted by mtime descending.
+ */
+export function listCodexTranscripts() {
+    const root = CODEX_SESSIONS_DIR();
+    if (!existsSync(root))
+        return [];
+    const out = [];
+    for (const year of safeReaddir(root)) {
+        for (const month of safeReaddir(join(root, year))) {
+            for (const day of safeReaddir(join(root, year, month))) {
+                const dayDir = join(root, year, month, day);
+                for (const f of safeReaddir(dayDir)) {
+                    if (!f.endsWith('.jsonl'))
+                        continue;
+                    const p = join(dayDir, f);
+                    try {
+                        const s = statSync(p);
+                        out.push({ path: p, mtimeMs: s.mtimeMs, cwd: '' });
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+    return out.sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+/**
+ * Pick the most recently active Codex transcript within `withinMs`.
+ */
+export function findActiveCodexTranscript(withinMs = 5 * 60_000) {
+    const list = listCodexTranscripts();
+    if (list.length === 0)
+        return null;
+    const top = list[0];
+    if (Date.now() - top.mtimeMs > withinMs) {
+        return { path: top.path, cwd: top.cwd };
+    }
+    return { path: top.path, cwd: top.cwd };
+}
+/**
+ * Apply a single Codex JSONL line to a running stats object.
+ * Codex emits `event_msg / token_count` events with `last_token_usage`
+ * (per-turn delta). Summing deltas across a session equals the cumulative
+ * total, so we use the same additive approach as the Claude parser.
+ */
+export function applyCodexLine(stats, line) {
+    let evt;
+    try {
+        evt = JSON.parse(line);
+    }
+    catch {
+        return;
+    }
+    const ts = parseTimestamp(evt?.timestamp);
+    if (ts) {
+        stats.startedAt = stats.startedAt ? Math.min(stats.startedAt, ts) : ts;
+        stats.lastEventAt = stats.lastEventAt ? Math.max(stats.lastEventAt, ts) : ts;
+    }
+    if (evt?.type === 'session_meta' && typeof evt?.payload?.cwd === 'string') {
+        if (!stats.cwd)
+            stats.cwd = evt.payload.cwd;
+    }
+    if (evt?.type !== 'event_msg')
+        return;
+    if (evt?.payload?.type !== 'token_count')
+        return;
+    const info = evt?.payload?.info;
+    if (!info)
+        return;
+    const last = info.last_token_usage;
+    if (!last)
+        return;
+    const u = {
+        input_tokens: numberOr0(last.input_tokens),
+        output_tokens: numberOr0(last.output_tokens) + numberOr0(last.reasoning_output_tokens),
+        cache_read_input_tokens: numberOr0(last.cached_input_tokens),
+        cache_creation_input_tokens: 0,
+    };
+    stats.totals = addUsage(stats.totals, u);
+    stats.byModel['codex'] = addUsage(stats.byModel['codex'] ?? EMPTY_USAGE(), u);
+    stats.lastModel = 'codex';
+    stats.messageCount += 1;
+}

package/dist/core/tailer.js

@@ -1,13 +1,15 @@
 import { open, watch } from 'node:fs/promises';
 import { statSync } from 'node:fs';
-import { applyLine } from './parser.js';
+import { applyLine, applyCodexLine } from './parser.js';
 import { EMPTY_USAGE } from './types.js';
 import { deriveSessionId } from './parser.js';
 /**
  * Open a JSONL transcript, read everything currently in it, then watch for
  * appended lines. Calls onUpdate whenever the stats change.
  */
-export async function tailTranscript(path) {
+export async function tailTranscript(path, format) {
+    const isCodex = format === 'codex' || path.includes('/.codex/sessions/');
+    const lineApplier = isCodex ? applyCodexLine : applyLine;
     const stats = {
         sessionId: deriveSessionId(path),
         transcriptPath: path,
@@ -44,7 +46,7 @@ export async function tailTranscript(path) {
             const line = buf.slice(0, nl);
             buf = buf.slice(nl + 1);
             if (line.trim()) {
-                applyLine(stats, line);
+                lineApplier(stats, line);
                 changed = true;
             }
         }

package/dist/statusline/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { aggregateTranscript, findActiveTranscript } from '../core/parser.js';
+import { aggregateAnyTranscript, findMostRecentActiveTranscript } from '../core/parser.js';
 import { detectAuth } from '../core/detect.js';
 import { estimateCostUSD, fmtNumber, fmtUSD } from '../core/format.js';
 import { totalTokens } from '../core/types.js';
@@ -16,13 +16,13 @@ if (OPTS.help) {
  */
 async function main() {
     try {
-        const active = findActiveTranscript();
+        const active = findMostRecentActiveTranscript();
         const auth = detectAuth();
         if (!active) {
             process.stdout.write(authBadge(auth) + ' · no active session');
             return;
         }
-        const s = await aggregateTranscript(active.path);
+        const s = await aggregateAnyTranscript(active.path);
         const model = s.lastModel ?? 'unknown';
         const tot = totalTokens(s.totals);
         const cost = estimateCostUSD(model, s.totals);

package/dist/tui/index.js

@@ -4,7 +4,7 @@ import { useEffect, useRef, useState } from 'react';
 import { render, Box, Text, useApp, useInput } from 'ink';
 import { createInterface } from 'node:readline';
 import { spawnSync } from 'node:child_process';
-import { findActiveTranscript, listTranscripts } from '../core/parser.js';
+import { findMostRecentActiveTranscript, listTranscripts } from '../core/parser.js';
 import { tailTranscript } from '../core/tailer.js';
 import { detectAuth } from '../core/detect.js';
 import { categoryCostUSD, contextWindowSize, estimateCostUSD, fmtNumber, fmtUSD } from '../core/format.js';
@@ -157,7 +157,7 @@ function App() {
             });
         }
         async function rescan() {
-            const active = findActiveTranscript();
+            const active = findMostRecentActiveTranscript();
             if (active && active.path !== transcriptPath)
                 await attach(active.path);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tokens-metric",
-  "version": "0.4.2",
-  "description": "Real-time token usage meter for Claude Code — statusline + Ink TUI.",
+  "version": "0.4.3",
+  "description": "Real-time token usage meter for Claude Code \u2014 statusline + Ink TUI.",
   "type": "module",
   "bin": {
     "tokens-metric": "dist/tui/index.js",