aieracard 0.1.1 → 0.1.2

package/README.md

@@ -9,9 +9,10 @@ npx aieracard
 The CLI collects usage **locally** from:
 
 - **Claude Code** — local JSONL logs (`~/.claude/projects`), fully automatic
+- **Codex** — local JSONL under `~/.codex/sessions` (override with `CODEX_HOME`)
 - **Cursor** — all-time usage via your own cursor.com session (token resolved
   locally, sent only to cursor.com); CSV export as fallback
-- **OpenRouter** — management API key (read-only `/credits` + `/activity`).
+- **OpenRouter** — optional management API key (`/credits` + `/activity`).
   Tokens are last 30 days; all-time spend stays on the source object and is
   **not** rolled into the card's aggregate "compute spent"
 
@@ -33,7 +34,7 @@ that unfurls into a stats card when shared.
 --openrouter-key <k>   OpenRouter API key (or OPENROUTER_API_KEY env)
 --cursor-cookie <t>    Cursor web session token (auto-detected if omitted)
 --cursor-csv <path>    usage CSV export (fallback if the API path fails)
---no-claude-code / --no-openrouter / --no-cursor
+--no-claude-code / --no-codex / --no-openrouter / --no-cursor
 --handle <name>        display name on the card (unverified)
 --open                 open the card URL in your browser
 ```

package/dist/index.js

@@ -4102,13 +4102,28 @@ var cursorSourceSchema = external_exports.object({
   dateRange: external_exports.object({ from: dateOnly, to: dateOnly }),
   models
 });
+var codexSourceSchema = external_exports.object({
+  tokensIn: tokens,
+  tokensOut: tokens,
+  cacheReadTokens: tokens,
+  reasoningTokens: tokens,
+  totalTokens: tokens,
+  estimatedCostUsd: costUsd.nullable(),
+  costConfidence: external_exports.enum(["estimated", "partial"]),
+  sessionCount: count,
+  activeDays: count,
+  longestStreakDays: count,
+  firstActivityDate: dateOnly,
+  lastActivityDate: dateOnly,
+  models
+});
 var aggregateSchema = external_exports.object({
   totalTokens: tokens,
   totalCostUsd: costUsd.nullable(),
   totalActiveDays: count,
   longestStreakDays: count,
   distinctModels: models,
-  sourceCount: external_exports.number().int().min(1).max(3),
+  sourceCount: external_exports.number().int().min(1).max(4),
   firstActivityDate: dateOnly,
   lastActivityDate: dateOnly
 });
@@ -4119,9 +4134,10 @@ var snapshotPayloadSchema = external_exports.object({
   sources: external_exports.object({
     claudeCode: claudeCodeSourceSchema.optional(),
     openrouter: openRouterSourceSchema.optional(),
-    cursor: cursorSourceSchema.optional()
+    cursor: cursorSourceSchema.optional(),
+    codex: codexSourceSchema.optional()
   }).refine(
-    (s) => s.claudeCode || s.openrouter || s.cursor,
+    (s) => s.claudeCode || s.openrouter || s.cursor || s.codex,
     "at least one source is required"
   ),
   aggregate: aggregateSchema,
@@ -4163,11 +4179,28 @@ var MODEL_PRICING = {
   "claude-3-5-sonnet": rates(3, 15),
   "claude-haiku-4-5": rates(1, 5),
   "claude-3-5-haiku": rates(0.8, 4),
-  "claude-3-haiku": rates(0.25, 1.25)
+  "claude-3-haiku": rates(0.25, 1.25),
+  // OpenAI / Codex CLI (USD per 1M; cache read ≈ 0.1× input via rates())
+  "gpt-5.4": rates(2.5, 15),
+  "gpt-5.3": rates(2.5, 15),
+  "gpt-5.2": rates(2.5, 15),
+  "gpt-5.1": rates(2.5, 15),
+  "gpt-5-mini": rates(0.4, 1.6),
+  "gpt-5-nano": rates(0.1, 0.4),
+  "gpt-5-codex": rates(2.5, 15),
+  "gpt-5": rates(2.5, 15),
+  "gpt-4.1-mini": rates(0.4, 1.6),
+  "gpt-4.1-nano": rates(0.1, 0.4),
+  "gpt-4.1": rates(2, 8),
+  "gpt-4o-mini": rates(0.15, 0.6),
+  "gpt-4o": rates(2.5, 10),
+  "o4-mini": rates(1.1, 4.4),
+  "o3-mini": rates(1.1, 4.4),
+  "o3": rates(2, 8)
 };
 var sortedKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
 function ratesFor(modelId) {
-  const normalized = modelId.replace(/^(anthropic\.|us\.anthropic\.)/, "");
+  const normalized = modelId.replace(/^(anthropic\.|us\.anthropic\.|openai\/|openai\.)/, "").replace(/^models\//, "");
   for (const key of sortedKeys) {
     if (normalized.startsWith(key)) return MODEL_PRICING[key];
   }
@@ -4659,24 +4692,204 @@ async function collectCursorApi(cookie, onProgress) {
   };
 }
 
+// src/collectors/codex.ts
+import { createReadStream as createReadStream2 } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { createInterface as createInterface2 } from "readline";
+import { homedir as homedir3 } from "os";
+import { join as join3, relative } from "path";
+function codexHome() {
+  return process.env.CODEX_HOME?.split(",")[0]?.trim() || join3(homedir3(), ".codex");
+}
+function codexSessionsRoots(home = codexHome()) {
+  return [join3(home, "sessions"), join3(home, "archived_sessions")];
+}
+function asBucket(v) {
+  if (!v || typeof v !== "object") return null;
+  const o = v;
+  const n = (k) => typeof o[k] === "number" && Number.isFinite(o[k]) ? o[k] : 0;
+  return {
+    input_tokens: n("input_tokens"),
+    cached_input_tokens: n("cached_input_tokens"),
+    output_tokens: n("output_tokens"),
+    reasoning_output_tokens: n("reasoning_output_tokens"),
+    total_tokens: n("total_tokens")
+  };
+}
+function delta(cur, prev) {
+  if (!prev) return cur;
+  return {
+    input_tokens: Math.max(0, cur.input_tokens - prev.input_tokens),
+    cached_input_tokens: Math.max(
+      0,
+      cur.cached_input_tokens - prev.cached_input_tokens
+    ),
+    output_tokens: Math.max(0, cur.output_tokens - prev.output_tokens),
+    reasoning_output_tokens: Math.max(
+      0,
+      cur.reasoning_output_tokens - prev.reasoning_output_tokens
+    ),
+    total_tokens: Math.max(0, cur.total_tokens - prev.total_tokens)
+  };
+}
+function isZero(b) {
+  return b.input_tokens === 0 && b.cached_input_tokens === 0 && b.output_tokens === 0 && b.reasoning_output_tokens === 0 && b.total_tokens === 0;
+}
+async function listJsonlFiles(root) {
+  const out = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir2(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p2 = join3(dir, e.name);
+      if (e.isDirectory()) await walk(p2);
+      else if (e.isFile() && e.name.endsWith(".jsonl")) out.push(p2);
+    }
+  }
+  await walk(root);
+  return out;
+}
+async function collectCodex(home = codexHome()) {
+  const sessionRoot = join3(home, "sessions");
+  const archivedRoot = join3(home, "archived_sessions");
+  const activeFiles = await listJsonlFiles(sessionRoot);
+  const archivedFiles = await listJsonlFiles(archivedRoot);
+  const seenRel = new Set(
+    activeFiles.map((f) => relative(sessionRoot, f).replace(/\\/g, "/"))
+  );
+  const files = [
+    ...activeFiles,
+    ...archivedFiles.filter((f) => {
+      const rel = relative(archivedRoot, f).replace(/\\/g, "/");
+      return !seenRel.has(rel);
+    })
+  ];
+  if (files.length === 0) return null;
+  let tokensIn = 0;
+  let tokensOut = 0;
+  let cacheRead = 0;
+  let reasoning = 0;
+  let costUsd2 = 0;
+  let hasUnpricedModel = false;
+  const sessions = /* @__PURE__ */ new Set();
+  const activeDates = /* @__PURE__ */ new Set();
+  const models2 = /* @__PURE__ */ new Set();
+  let firstDate = null;
+  let lastDate = null;
+  let filesParsed = 0;
+  for (const file of files) {
+    filesParsed++;
+    sessions.add(file);
+    let prevTotals = null;
+    let currentModel = null;
+    const rl = createInterface2({
+      input: createReadStream2(file),
+      crlfDelay: Infinity
+    });
+    for await (const line of rl) {
+      if (!line.includes("token_count") && !line.includes("turn_context") && !line.includes("session_meta")) {
+        continue;
+      }
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const ts = typeof entry.timestamp === "string" ? toDateOnly(entry.timestamp) : null;
+      if (entry.type === "turn_context") {
+        const model = entry.payload?.model ?? entry.payload?.info?.model ?? entry.model;
+        if (typeof model === "string" && model) currentModel = model;
+        continue;
+      }
+      if (entry.type === "session_meta") {
+        const id = entry.payload?.id ?? entry.payload?.session_id;
+        if (typeof id === "string" && id) {
+          sessions.delete(file);
+          sessions.add(id);
+        }
+        continue;
+      }
+      if (entry.type !== "event_msg") continue;
+      if (entry.payload?.type !== "token_count") continue;
+      const total = asBucket(entry.payload?.info?.total_token_usage);
+      if (!total) continue;
+      const d = delta(total, prevTotals);
+      prevTotals = total;
+      if (isZero(d)) continue;
+      const cached = d.cached_input_tokens;
+      const nonCachedIn = Math.max(0, d.input_tokens - cached);
+      const outTok = d.output_tokens;
+      const reasonTok = d.reasoning_output_tokens;
+      tokensIn += d.input_tokens;
+      cacheRead += cached;
+      tokensOut += outTok;
+      reasoning += reasonTok;
+      if (currentModel) {
+        models2.add(currentModel);
+        const r = ratesFor(currentModel);
+        if (r) {
+          costUsd2 += (nonCachedIn * r.input + cached * r.cacheRead + outTok * r.output) / 1e6;
+        } else {
+          hasUnpricedModel = true;
+        }
+      } else {
+        hasUnpricedModel = true;
+      }
+      if (ts) {
+        activeDates.add(ts);
+        if (!firstDate || ts < firstDate) firstDate = ts;
+        if (!lastDate || ts > lastDate) lastDate = ts;
+      }
+    }
+  }
+  const totalTokens = tokensIn + tokensOut;
+  if (totalTokens === 0 || !firstDate || !lastDate) return null;
+  return {
+    source: {
+      tokensIn,
+      tokensOut,
+      cacheReadTokens: cacheRead,
+      reasoningTokens: reasoning,
+      totalTokens,
+      estimatedCostUsd: Math.round(costUsd2 * 100) / 100,
+      costConfidence: hasUnpricedModel ? "partial" : "estimated",
+      sessionCount: sessions.size,
+      activeDays: activeDates.size,
+      longestStreakDays: longestStreak(activeDates),
+      firstActivityDate: firstDate,
+      lastActivityDate: lastDate,
+      models: [...models2].sort().slice(0, 50)
+    },
+    activeDates,
+    filesParsed
+  };
+}
+
 // src/merge.ts
-var CLI_VERSION = "0.1.1";
+var CLI_VERSION = "0.1.2";
 function buildPayload(opts) {
-  const { claudeCode, openrouter, cursor, handle } = opts;
+  const { claudeCode, openrouter, cursor, codex, handle } = opts;
   const allDates = /* @__PURE__ */ new Set();
-  for (const r of [claudeCode, openrouter, cursor]) {
+  for (const r of [claudeCode, openrouter, cursor, codex]) {
     if (r) for (const d of r.activeDates) allDates.add(d);
   }
-  const totalTokens = (claudeCode?.source.totalTokens ?? 0) + (openrouter?.source.totalTokens ?? 0) + (cursor?.source.totalTokens ?? 0);
+  const totalTokens = (claudeCode?.source.totalTokens ?? 0) + (openrouter?.source.totalTokens ?? 0) + (cursor?.source.totalTokens ?? 0) + (codex?.source.totalTokens ?? 0);
   const costs = [
     claudeCode?.source.estimatedCostUsd,
-    cursor?.source.totalCostUsd
+    cursor?.source.totalCostUsd,
+    codex?.source.estimatedCostUsd
   ].filter((c) => typeof c === "number");
   const totalCostUsd = costs.length > 0 ? Math.round(costs.reduce((a, b) => a + b, 0) * 100) / 100 : null;
   const distinctModels = /* @__PURE__ */ new Set([
     ...claudeCode?.source.models ?? [],
     ...openrouter?.source.models ?? [],
-    ...cursor?.source.models ?? []
+    ...cursor?.source.models ?? [],
+    ...codex?.source.models ?? []
   ]);
   let first = null;
   let last = null;
@@ -4684,6 +4897,10 @@ function buildPayload(opts) {
     first = minDate(first, claudeCode.source.firstActivityDate);
     last = maxDate(last, claudeCode.source.lastActivityDate);
   }
+  if (codex) {
+    first = minDate(first, codex.source.firstActivityDate);
+    last = maxDate(last, codex.source.lastActivityDate);
+  }
   if (cursor) {
     first = minDate(first, cursor.source.dateRange.from);
     last = maxDate(last, cursor.source.dateRange.to);
@@ -4700,7 +4917,8 @@ function buildPayload(opts) {
     sources: {
       ...claudeCode ? { claudeCode: claudeCode.source } : {},
       ...openrouter ? { openrouter: openrouter.source } : {},
-      ...cursor ? { cursor: cursor.source } : {}
+      ...cursor ? { cursor: cursor.source } : {},
+      ...codex ? { codex: codex.source } : {}
     },
     aggregate: {
       totalTokens,
@@ -4708,7 +4926,7 @@ function buildPayload(opts) {
       totalActiveDays: allDates.size,
       longestStreakDays: longestStreak(allDates),
       distinctModels: [...distinctModels].sort().slice(0, 50),
-      sourceCount: [claudeCode, openrouter, cursor].filter(Boolean).length,
+      sourceCount: [claudeCode, openrouter, cursor, codex].filter(Boolean).length,
       firstActivityDate: first ?? today,
       lastActivityDate: last ?? today
     },
@@ -4730,6 +4948,7 @@ var { values: args } = parseArgs({
     "no-claude-code": { type: "boolean", default: false },
     "no-openrouter": { type: "boolean", default: false },
     "no-cursor": { type: "boolean", default: false },
+    "no-codex": { type: "boolean", default: false },
     handle: { type: "string" },
     endpoint: { type: "string" },
     open: { type: "boolean", default: false },
@@ -4764,6 +4983,7 @@ Options:
   --cursor-cookie <t>    Cursor web session token (auto-detected if omitted)
   --cursor-csv <path>    usage CSV export (fallback if the API path fails)
   --no-claude-code       skip Claude Code logs
+  --no-codex             skip OpenAI Codex CLI logs
   --no-openrouter        skip OpenRouter
   --no-cursor            skip Cursor
   --handle <name>        display name on the card (unverified)
@@ -4789,6 +5009,19 @@ Options:
       s2.stop("Claude Code: no local logs found \u2014 skipping");
     }
   }
+  let codex = null;
+  if (!args["no-codex"]) {
+    const s2 = p.spinner();
+    s2.start(`Scanning Codex logs (${codexSessionsRoots().join(", ")})`);
+    codex = await collectCodex();
+    if (codex) {
+      s2.stop(
+        `Codex: ${fmt(codex.source.totalTokens)} tokens across ${codex.source.sessionCount} sessions (${codex.filesParsed} log files)`
+      );
+    } else {
+      s2.stop("Codex: no local session logs found \u2014 skipping");
+    }
+  }
   let openrouter = null;
   if (!args["no-openrouter"]) {
     let key = args["openrouter-key"] ?? process.env.OPENROUTER_API_KEY ?? "";
@@ -4876,9 +5109,9 @@ Options:
       }
     }
   }
-  if (!claudeCode && !openrouter && !cursor) {
+  if (!claudeCode && !openrouter && !cursor && !codex) {
     bail(
-      "No usage sources found or supplied. Nothing to build a card from.\nTry --openrouter-key or --cursor-csv, or run Claude Code first."
+      "No usage sources found or supplied. Nothing to build a card from.\nTry Claude Code, Codex CLI, --openrouter-key, or --cursor-csv."
     );
   }
   let handle = args.handle ?? null;
@@ -4893,6 +5126,7 @@ Options:
     claudeCode,
     openrouter,
     cursor,
+    codex,
     handle
   });
   const parsed = snapshotPayloadSchema.safeParse(payload);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aieracard",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Generate a shareable card from your AI tool usage. Local parsing, aggregate numbers only.",
   "type": "module",
   "bin": {