aieracard 0.1.0 → 0.1.2

package/README.md

@@ -9,9 +9,12 @@ 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** — via your API key (read-only endpoints)
+- **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"
 
 It then shows you the **exact JSON** that would be uploaded — aggregate
 numbers only: token counts, cost totals, active days, streaks, model names.
@@ -31,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

@@ -4084,8 +4084,11 @@ var claudeCodeSourceSchema = external_exports.object({
   models
 });
 var openRouterSourceSchema = external_exports.object({
+  // Tokens/requests/models are last-30-day (/activity). totalCostUsd is
+  // all-time spend from /credits — nullable if that endpoint fails.
+  // Aggregate card totals intentionally omit this cost (mixed windows).
   totalTokens: tokens,
-  totalCostUsd: costUsd,
+  totalCostUsd: costUsd.nullable(),
   requestCount: count,
   activeDays: count,
   windowDays: external_exports.literal(30),
@@ -4099,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
 });
@@ -4116,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,
@@ -4160,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];
   }
@@ -4339,41 +4375,69 @@ async function validateOpenRouterKey(key) {
     return false;
   }
 }
+function parseCostUsd(credits) {
+  if (!credits || typeof credits !== "object") return null;
+  const data = credits.data;
+  const raw = data?.total_usage;
+  return typeof raw === "number" && Number.isFinite(raw) && raw >= 0 ? Math.round(raw * 100) / 100 : null;
+}
+function parseActivityRows(activity) {
+  if (!activity || typeof activity !== "object") return [];
+  const data = activity.data;
+  return Array.isArray(data) ? data : [];
+}
 async function collectOpenRouter(key) {
-  const [credits, activity] = await Promise.all([
-    get("/credits", key).catch(() => null),
-    get("/activity", key).catch(() => null)
-  ]);
-  const totalCostUsd = credits?.data?.total_usage ?? credits?.data?.usage ?? 0;
-  const rows = activity?.data ?? [];
+  const warnings = [];
+  let credits = null;
+  try {
+    credits = await get("/credits", key);
+  } catch (e) {
+    warnings.push(
+      `/credits failed (${e.message}) \u2014 all-time spend unknown; tokens still from last 30 days`
+    );
+  }
+  let activity;
+  try {
+    activity = await get("/activity", key);
+  } catch (e) {
+    throw new Error(
+      `OpenRouter /activity failed (${e.message}). Need a management API key with activity access.`
+    );
+  }
+  const totalCostUsd = parseCostUsd(credits);
+  if (credits != null && totalCostUsd == null) {
+    warnings.push("/credits returned an unexpected shape \u2014 spend left unknown");
+  }
+  const rows = parseActivityRows(activity);
   let totalTokens = 0;
   let requestCount = 0;
   const activeDates = /* @__PURE__ */ new Set();
   const models2 = /* @__PURE__ */ new Set();
   for (const row of rows) {
-    totalTokens += (row.prompt_tokens ?? 0) + (row.completion_tokens ?? 0) + (row.reasoning_tokens ?? 0);
-    requestCount += row.requests ?? 0;
+    totalTokens += (Number(row.prompt_tokens) || 0) + (Number(row.completion_tokens) || 0) + (Number(row.reasoning_tokens) || 0);
+    requestCount += Number(row.requests) || 0;
     if (typeof row.date === "string") {
       const d = row.date.slice(0, 10);
       if (/^\d{4}-\d{2}-\d{2}$/.test(d)) activeDates.add(d);
     }
     if (typeof row.model === "string" && row.model) models2.add(row.model);
-    if (typeof row.model_permaslug === "string" && row.model_permaslug)
+    else if (typeof row.model_permaslug === "string" && row.model_permaslug)
       models2.add(row.model_permaslug);
   }
-  if (totalTokens === 0 && totalCostUsd === 0 && requestCount === 0) {
+  if (totalTokens === 0 && requestCount === 0 && totalCostUsd == null) {
     return null;
   }
   return {
     source: {
       totalTokens: Math.round(totalTokens),
-      totalCostUsd: Math.round(totalCostUsd * 100) / 100,
+      totalCostUsd,
       requestCount,
       activeDays: activeDates.size,
       windowDays: 30,
       models: [...models2].sort().slice(0, 50)
     },
-    activeDates
+    activeDates,
+    warnings
   };
 }
 
@@ -4628,25 +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.0";
+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,
-    openrouter?.source.totalCostUsd,
-    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;
@@ -4654,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);
@@ -4670,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,
@@ -4678,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
     },
@@ -4700,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 },
@@ -4734,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)
@@ -4759,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 ?? "";
@@ -4775,12 +5038,27 @@ Options:
       s2.start("Validating OpenRouter key");
       if (await validateOpenRouterKey(key)) {
         s2.message("Fetching OpenRouter usage");
-        openrouter = await collectOpenRouter(key);
+        try {
+          openrouter = await collectOpenRouter(key);
+          for (const w of openrouter?.warnings ?? []) {
+            p.log.warn(`OpenRouter: ${w}`);
+          }
+          if (openrouter) {
+            const spend = openrouter.source.totalCostUsd != null ? `$${openrouter.source.totalCostUsd} all-time spend (not rolled into card total)` : "spend unknown";
+            s2.stop(
+              `OpenRouter: ${fmt(openrouter.source.totalTokens)} tokens (last 30 days), ${spend}`
+            );
+          } else {
+            s2.stop("OpenRouter: no usage found \u2014 skipping");
+          }
+        } catch (e) {
+          openrouter = null;
+          s2.stop(`OpenRouter: ${e.message} \u2014 skipping`);
+        }
+      } else {
         s2.stop(
-          openrouter ? `OpenRouter: $${openrouter.source.totalCostUsd} all-time, ${fmt(openrouter.source.totalTokens)} tokens (last 30 days)` : "OpenRouter: no usage found \u2014 skipping"
+          "OpenRouter: key invalid or not a management key \u2014 skipping"
         );
-      } else {
-        s2.stop("OpenRouter: key invalid \u2014 skipping");
       }
     }
   }
@@ -4831,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;
@@ -4848,6 +5126,7 @@ Options:
     claudeCode,
     openrouter,
     cursor,
+    codex,
     handle
   });
   const parsed = snapshotPayloadSchema.safeParse(payload);

package/package.json

@@ -1,16 +1,23 @@
 {
   "name": "aieracard",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Generate a shareable card from your AI tool usage. Local parsing, aggregate numbers only.",
   "type": "module",
   "bin": {
-    "aieracard": "./dist/index.js"
+    "aieracard": "dist/index.js"
   },
   "files": [
     "dist",
     "README.md"
   ],
   "license": "MIT",
+  "homepage": "https://ai-era-card.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sinsmilex/ai-era-card.git",
+    "directory": "apps/cli"
+  },
+  "bugs": "https://github.com/sinsmilex/ai-era-card/issues",
   "keywords": [
     "ai",
     "usage",
@@ -27,7 +34,8 @@
   "scripts": {
     "build": "tsup",
     "start": "node dist/index.js",
-    "dev": "tsup --watch"
+    "dev": "tsup --watch",
+    "test": "vitest run"
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
@@ -37,6 +45,7 @@
     "@aieracard/schema": "workspace:*",
     "@types/node": "^22",
     "tsup": "^8.3.5",
-    "typescript": "^5.6.3"
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.9"
   }
 }