@tokz/cli 0.2.11 → 0.2.13

package/dist/{Root-T2V2YHJ2.js → Root-HZIVZ2YT.js}

@@ -632,117 +632,210 @@ var codebuffAdapter = {
 };
 
 // src/agents/codex.ts
-import { createReadStream } from "fs";
-import { access as access5 } from "fs/promises";
-import { createInterface } from "readline";
+import { access as access5, readFile as readFile4, stat as stat2 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import { join as join6 } from "path";
 import { glob as glob4 } from "tinyglobby";
-import { z } from "zod";
-var TokenTotals = z.object({
-  input_tokens: z.number().catch(0).default(0),
-  cached_input_tokens: z.number().catch(0).default(0),
-  output_tokens: z.number().catch(0).default(0),
-  reasoning_output_tokens: z.number().catch(0).default(0),
-  total_tokens: z.number().catch(0).default(0)
-});
-var Line = z.object({
-  timestamp: z.string().optional(),
-  type: z.string().optional(),
-  // old-format meta lines carry cwd at the top level
-  cwd: z.string().optional(),
-  payload: z.object({
-    type: z.string().optional(),
-    cwd: z.string().optional(),
-    model: z.string().optional(),
-    name: z.string().optional(),
-    info: z.object({
-      total_token_usage: TokenTotals.optional(),
-      // Codex writes the per-turn amount here directly; prefer it over
-      // differencing cumulative totals.
-      last_token_usage: TokenTotals.optional()
-    }).nullish()
-  }).passthrough().optional()
-});
-function codexHome(home) {
-  if (home) return join6(home, ".codex");
-  return process.env.CODEX_HOME ?? join6(homedir6(), ".codex");
-}
 var DEFAULT_MODEL = "gpt-5";
+var CODEX_AUTO_REVIEW_MODEL = "codex-auto-review";
+var CODEX_AUTO_REVIEW_FALLBACKS = [
+  { releasedOn: "2026-04-23", model: "gpt-5.5" },
+  { releasedOn: "2026-03-05", model: "gpt-5.4" },
+  { releasedOn: "2026-02-05", model: "gpt-5.3-codex" },
+  { releasedOn: "2025-12-11", model: "gpt-5.2-codex" },
+  { releasedOn: "2025-11-13", model: "gpt-5.1-codex" },
+  { releasedOn: "2025-09-15", model: "gpt-5-codex" },
+  { releasedOn: "2025-08-07", model: "gpt-5" }
+];
+function codexHomes(home) {
+  if (home) return [join6(home, ".codex")];
+  const env = process.env.CODEX_HOME;
+  if (env) {
+    return env.split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+  }
+  return [join6(homedir6(), ".codex")];
+}
+function asDict(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+}
+function u64(v) {
+  if (typeof v === "number") {
+    return Number.isInteger(v) && v >= 0 ? v : void 0;
+  }
+  if (typeof v === "string") {
+    const t = v.trim();
+    return /^\d+$/.test(t) ? Number(t) : void 0;
+  }
+  return void 0;
+}
+function rawUsage(v) {
+  const o = asDict(v);
+  if (!o) return void 0;
+  const input = u64(o.input_tokens) ?? u64(o.prompt_tokens) ?? u64(o.input) ?? 0;
+  const cached = u64(o.cached_input_tokens) ?? u64(o.cache_read_input_tokens) ?? u64(o.cached_tokens) ?? 0;
+  const output = u64(o.output_tokens) ?? u64(o.completion_tokens) ?? u64(o.output) ?? 0;
+  const reasoning = u64(o.reasoning_output_tokens) ?? u64(o.reasoning_tokens) ?? 0;
+  const sum = input + output + reasoning;
+  const totalField = u64(o.total_tokens);
+  const total = totalField !== void 0 && (totalField > 0 || sum === 0) ? totalField : sum;
+  return { input, cached, output, reasoning, total };
+}
+function subtractUsage(current, previous) {
+  return {
+    input: Math.max(0, current.input - (previous?.input ?? 0)),
+    cached: Math.max(0, current.cached - (previous?.cached ?? 0)),
+    output: Math.max(0, current.output - (previous?.output ?? 0)),
+    reasoning: Math.max(0, current.reasoning - (previous?.reasoning ?? 0)),
+    total: Math.max(0, current.total - (previous?.total ?? 0))
+  };
+}
+function nonEmpty(v) {
+  if (typeof v !== "string") return void 0;
+  const t = v.trim();
+  return t.length > 0 ? t : void 0;
+}
+function modelFromParts(v) {
+  const o = asDict(v);
+  if (!o) return void 0;
+  return nonEmpty(o.model) ?? nonEmpty(o.model_name) ?? nonEmpty(asDict(o.metadata)?.model);
+}
+function timestampDate(ts) {
+  const date = ts.slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) return void 0;
+  const year = Number(date.slice(0, 4));
+  const month = Number(date.slice(5, 7));
+  const day = Number(date.slice(8, 10));
+  const daysInMonth = month === 2 ? year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28 : [1, 3, 5, 7, 8, 10, 12].includes(month) ? 31 : [4, 6, 9, 11].includes(month) ? 30 : void 0;
+  if (daysInMonth === void 0 || day < 1 || day > daysInMonth) return void 0;
+  return date;
+}
+function autoReviewFallback(model, timestamp) {
+  if (model !== CODEX_AUTO_REVIEW_MODEL) return void 0;
+  const date = timestampDate(timestamp);
+  if (!date) return DEFAULT_MODEL;
+  return CODEX_AUTO_REVIEW_FALLBACKS.find((f) => date >= f.releasedOn)?.model ?? DEFAULT_MODEL;
+}
+function resolveModel(parsed, timestamp, state) {
+  if (parsed !== void 0) {
+    state.current = parsed;
+    state.currentIsFallback = false;
+  }
+  let model = parsed ?? state.current;
+  if (model === void 0) {
+    state.currentIsFallback = true;
+    state.current = DEFAULT_MODEL;
+    model = DEFAULT_MODEL;
+  }
+  return autoReviewFallback(model, timestamp) ?? model;
+}
+function normalizeTimestamp(v) {
+  if (typeof v === "string") {
+    const t = v.trim();
+    if (t.length === 0) return void 0;
+    const ms2 = Date.parse(t);
+    return Number.isNaN(ms2) ? void 0 : new Date(ms2).toISOString();
+  }
+  const raw = u64(v);
+  if (raw === void 0) return void 0;
+  const ms = raw > 1e10 ? raw : raw * 1e3;
+  return new Date(ms).toISOString();
+}
+function rawOrNormalizedTimestamp(v) {
+  if (typeof v === "string") {
+    const t = v.trim();
+    if (t.length === 0) return void 0;
+    if (timestampDate(t) !== void 0) return t;
+    return normalizeTimestamp(t);
+  }
+  return normalizeTimestamp(v);
+}
+function tsSecond(ts) {
+  return (ts ?? "").slice(0, 19);
+}
+function parseLine(raw) {
+  let obj;
+  try {
+    obj = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const o = asDict(obj);
+  if (!o) return void 0;
+  return {
+    timestamp: typeof o.timestamp === "string" ? o.timestamp : void 0,
+    type: typeof o.type === "string" ? o.type : void 0,
+    cwd: typeof o.cwd === "string" ? o.cwd : void 0,
+    payload: asDict(o.payload),
+    obj: o
+  };
+}
+function tokenCountInfo(p) {
+  return p.type === "event_msg" && p.payload?.type === "token_count" ? asDict(p.payload.info) : void 0;
+}
+function replayBurstSecond(content, lines) {
+  const head = content.slice(0, 16384);
+  if (!head.includes("thread_spawn") && !head.includes("forked_from_id")) return void 0;
+  let first;
+  for (const p of lines) {
+    const info = tokenCountInfo(p);
+    if (!info) continue;
+    if (!asDict(info.last_token_usage) && !asDict(info.total_token_usage)) continue;
+    const sec = tsSecond(p.timestamp);
+    if (first === void 0) first = sec;
+    else return first === sec ? first : void 0;
+  }
+  return void 0;
+}
+function headlessUsage(o) {
+  const usage = rawUsage(asDict(o.usage)) ?? rawUsage(asDict(asDict(o.data)?.usage)) ?? rawUsage(asDict(asDict(o.result)?.usage)) ?? rawUsage(asDict(asDict(o.response)?.usage));
+  if (!usage) return void 0;
+  if (usage.input === 0 && usage.cached === 0 && usage.output === 0 && usage.reasoning === 0 && usage.total === 0) {
+    return void 0;
+  }
+  return usage;
+}
+function headlessModel(o) {
+  return modelFromParts(o) ?? modelFromParts(asDict(o.data)) ?? modelFromParts(asDict(o.result)) ?? modelFromParts(asDict(o.response));
+}
+function headlessTimestamp(o, pick) {
+  const fromFields = (f) => f ? pick(f.timestamp) ?? pick(f.created_at) ?? pick(f.createdAt) : void 0;
+  return fromFields(o) ?? fromFields(asDict(o.data)) ?? fromFields(asDict(o.result)) ?? fromFields(asDict(o.response));
+}
 async function parseCodexRollout(file, seen = /* @__PURE__ */ new Set()) {
   const stats = { file, usageByModel: {}, toolCalls: {}, toolCostUsd: {}, dailyUsage: {} };
-  const rl = createInterface({ input: createReadStream(file, "utf8"), crlfDelay: Infinity });
-  let model = DEFAULT_MODEL;
-  let prev = { input: 0, cached: 0, output: 0, total: 0 };
-  let turnTools = [];
-  for await (const raw of rl) {
+  const content = await readFile4(file, "utf8").catch(() => "");
+  const lines = [];
+  for (const raw of content.split("\n")) {
     if (!raw.trim()) continue;
-    let obj;
-    try {
-      obj = JSON.parse(raw);
-    } catch {
-      continue;
-    }
-    const parsed = Line.safeParse(obj);
-    if (!parsed.success) continue;
-    const { timestamp, type, payload: payload2 } = parsed.data;
-    if (!stats.cwd) stats.cwd = payload2?.cwd ?? parsed.data.cwd;
-    if (payload2?.model) model = payload2.model;
-    if (timestamp) {
-      if (!stats.firstTs) stats.firstTs = timestamp;
-      stats.lastTs = timestamp;
-    }
-    const toolName = payload2?.type === "function_call" || payload2?.type === "custom_tool_call" ? payload2.name : payload2?.type === "local_shell_call" ? "shell" : type === "function_call" ? parsed.data.name : void 0;
-    if (toolName) {
-      stats.toolCalls[toolName] = (stats.toolCalls[toolName] ?? 0) + 1;
-      turnTools.push(toolName);
+    const parsed = parseLine(raw);
+    if (parsed) lines.push(parsed);
+  }
+  const burstSecond = replayBurstSecond(content, lines);
+  let skippingReplay = burstSecond !== void 0;
+  const modelState = { currentIsFallback: false };
+  let prev;
+  let turnTools = [];
+  let mtimeIso;
+  const fileMtime = async () => {
+    if (mtimeIso === void 0) {
+      mtimeIso = await stat2(file).then((s) => s.mtime.toISOString()).catch(() => (/* @__PURE__ */ new Date(0)).toISOString());
     }
-    const info = payload2?.type === "token_count" ? payload2.info : void 0;
-    const last = info?.last_token_usage;
-    const totals = info?.total_token_usage;
-    if (!last && !totals) continue;
-    const idTotals = last ?? totals;
-    const dedupKey = `${timestamp ?? ""}|${model}|${idTotals.input_tokens}|${idTotals.cached_input_tokens}|${idTotals.output_tokens}|${idTotals.reasoning_output_tokens}|${idTotals.total_tokens}`;
-    let dInput;
-    let dCached;
-    let dOutput;
-    if (last) {
-      dInput = last.input_tokens;
-      dCached = last.cached_input_tokens;
-      dOutput = last.output_tokens;
-      if (totals) {
-        prev = {
-          input: totals.input_tokens,
-          cached: totals.cached_input_tokens,
-          output: totals.output_tokens,
-          total: totals.total_tokens
-        };
-      }
-    } else {
-      const cur = {
-        input: totals.input_tokens,
-        cached: totals.cached_input_tokens,
-        output: totals.output_tokens,
-        total: totals.total_tokens
-      };
-      if (cur.total < prev.total) prev = { input: 0, cached: 0, output: 0, total: 0 };
-      dInput = Math.max(0, cur.input - prev.input);
-      dCached = Math.max(0, cur.cached - prev.cached);
-      dOutput = Math.max(0, cur.output - prev.output);
-      prev = cur;
-    }
-    if (dInput + dOutput === 0) continue;
+    return mtimeIso;
+  };
+  const accumulate = (usage, model, timestamp) => {
+    const cached = Math.min(usage.cached, usage.input);
+    const dedupKey = `${timestamp ?? ""}|${model}|${usage.input}|${cached}|${usage.output}|${usage.reasoning}|${usage.total}`;
     if (seen.has(dedupKey)) {
       turnTools = [];
-      continue;
+      return;
     }
     seen.add(dedupKey);
     const delta = {
       // Codex's input_tokens INCLUDES cached tokens; split them out.
-      inputTokens: Math.max(0, dInput - dCached),
-      cacheReadTokens: dCached,
+      inputTokens: Math.max(0, usage.input - cached),
+      cacheReadTokens: cached,
       cacheCreationTokens: 0,
-      outputTokens: dOutput,
+      outputTokens: usage.output,
       turns: 1
     };
     const accs = [stats.usageByModel[model] ??= emptyUsage()];
@@ -764,15 +857,84 @@ async function parseCodexRollout(file, seen = /* @__PURE__ */ new Set()) {
       }
     }
     turnTools = [];
+  };
+  for (const parsed of lines) {
+    const { timestamp, type, payload: payload2 } = parsed;
+    if (!stats.cwd) {
+      const payloadCwd = typeof payload2?.cwd === "string" ? payload2.cwd : void 0;
+      stats.cwd = payloadCwd ?? parsed.cwd;
+    }
+    if (timestamp) {
+      if (!stats.firstTs) stats.firstTs = timestamp;
+      stats.lastTs = timestamp;
+    }
+    const toolName = payload2?.type === "function_call" || payload2?.type === "custom_tool_call" ? nonEmpty(payload2.name) : payload2?.type === "local_shell_call" ? "shell" : type === "function_call" ? nonEmpty(parsed.obj.name) : void 0;
+    if (toolName) {
+      stats.toolCalls[toolName] = (stats.toolCalls[toolName] ?? 0) + 1;
+      turnTools.push(toolName);
+    }
+    if (type === "turn_context") {
+      const model2 = modelFromParts(payload2);
+      if (model2 !== void 0) {
+        modelState.current = model2;
+        modelState.currentIsFallback = false;
+      }
+      continue;
+    }
+    const info = tokenCountInfo(parsed);
+    if (info) {
+      const totals = rawUsage(info.total_token_usage);
+      const last = rawUsage(info.last_token_usage);
+      if (!last && !totals) continue;
+      if (skippingReplay && tsSecond(timestamp) === burstSecond) {
+        if (totals) prev = totals;
+        turnTools = [];
+        continue;
+      }
+      skippingReplay = false;
+      const usage2 = last ?? subtractUsage(totals, prev);
+      if (totals) prev = totals;
+      if (usage2.input === 0 && usage2.cached === 0 && usage2.output === 0 && usage2.reasoning === 0) {
+        continue;
+      }
+      const ts = nonEmpty(timestamp) ?? normalizeTimestamp(parsed.obj.timestamp);
+      const parsedModel = modelFromParts(payload2) ?? modelFromParts(info);
+      const model2 = resolveModel(parsedModel, ts ?? "", modelState);
+      accumulate(usage2, model2, ts);
+      continue;
+    }
+    if (type === "event_msg" || payload2?.type === "turn_context") continue;
+    const usage = headlessUsage(parsed.obj);
+    if (!usage) continue;
+    const eventTs = headlessTimestamp(parsed.obj, normalizeTimestamp) ?? await fileMtime();
+    const modelTs = headlessTimestamp(parsed.obj, rawOrNormalizedTimestamp) ?? await fileMtime();
+    const model = resolveModel(headlessModel(parsed.obj), modelTs, modelState);
+    accumulate(usage, model, eventTs);
   }
   return stats;
 }
 async function loadCodexProjects(home, onProgress) {
-  const root = codexHome(home);
-  const files = await glob4(["sessions/**/*.jsonl", "archived_sessions/**/*.jsonl"], {
-    cwd: root,
-    absolute: true
-  }).catch(() => []);
+  const files = [];
+  for (const root of codexHomes(home)) {
+    const sources = [];
+    for (const dir of ["sessions", "archived_sessions"]) {
+      const full = join6(root, dir);
+      const ok = await access5(full).then(() => true).catch(() => false);
+      if (ok) sources.push(full);
+    }
+    if (sources.length === 0) sources.push(root);
+    const seenRelative = /* @__PURE__ */ new Set();
+    for (const source of sources) {
+      const found = await glob4(["**/*.jsonl"], { cwd: source, absolute: false }).catch(() => []);
+      found.sort();
+      for (const rel of found) {
+        const key = rel.replaceAll("\\", "/");
+        if (seenRelative.has(key)) continue;
+        seenRelative.add(key);
+        files.push(join6(source, rel));
+      }
+    }
+  }
   if (files.length === 0) return [];
   const sessions = [];
   const seen = /* @__PURE__ */ new Set();
@@ -790,12 +952,11 @@ var codexAdapter = {
   name: "OpenAI Codex",
   supported: true,
   async detect(home) {
-    try {
-      await access5(join6(codexHome(home), "sessions"));
-      return true;
-    } catch {
-      return false;
+    for (const root of codexHomes(home)) {
+      const ok = await access5(join6(root, "sessions")).then(() => true).catch(() => false);
+      if (ok) return true;
     }
+    return false;
   },
   loadProjects: loadCodexProjects
 };
@@ -901,7 +1062,7 @@ var copilotAdapter = {
 };
 
 // src/agents/droid.ts
-import { access as access7, stat as stat2 } from "fs/promises";
+import { access as access7, stat as stat3 } from "fs/promises";
 import { homedir as homedir8 } from "os";
 import { basename as basename2, join as join8 } from "path";
 import { glob as glob6 } from "tinyglobby";
@@ -915,7 +1076,7 @@ async function parseFile2(file) {
   let ts = str(settings, "updatedAt") ?? str(settings, "createdAt");
   if (!ts) {
     try {
-      ts = (await stat2(file)).mtime.toISOString();
+      ts = (await stat3(file)).mtime.toISOString();
     } catch {
     }
   }
@@ -1031,7 +1192,7 @@ import { homedir as homedir10 } from "os";
 import { join as join10 } from "path";
 
 // src/sqlite.ts
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 function u8(b, o) {
   return b[o];
 }
@@ -1171,7 +1332,7 @@ function columnNames(sql) {
 async function readTable(file, table) {
   let buf;
   try {
-    buf = await readFile4(file);
+    buf = await readFile5(file);
   } catch {
     return [];
   }
@@ -1499,38 +1660,38 @@ var openclawAdapter = {
 };
 
 // src/agents/opencode.ts
-import { access as access14, readFile as readFile5 } from "fs/promises";
+import { access as access14, readFile as readFile6 } from "fs/promises";
 import { homedir as homedir15 } from "os";
 import { join as join15 } from "path";
 import { glob as glob10 } from "tinyglobby";
-import { z as z2 } from "zod";
-var Message = z2.object({
-  sessionID: z2.string(),
-  role: z2.string(),
-  modelID: z2.string().optional(),
-  providerID: z2.string().optional(),
-  time: z2.object({ created: z2.number().optional(), completed: z2.number().optional() }).optional(),
-  tokens: z2.object({
-    input: z2.number().catch(0).default(0),
-    output: z2.number().catch(0).default(0),
-    reasoning: z2.number().catch(0).default(0),
-    cache: z2.object({ read: z2.number().catch(0).default(0), write: z2.number().catch(0).default(0) }).optional()
+import { z } from "zod";
+var Message = z.object({
+  sessionID: z.string(),
+  role: z.string(),
+  modelID: z.string().optional(),
+  providerID: z.string().optional(),
+  time: z.object({ created: z.number().optional(), completed: z.number().optional() }).optional(),
+  tokens: z.object({
+    input: z.number().catch(0).default(0),
+    output: z.number().catch(0).default(0),
+    reasoning: z.number().catch(0).default(0),
+    cache: z.object({ read: z.number().catch(0).default(0), write: z.number().catch(0).default(0) }).optional()
   }).optional()
 });
-var Session = z2.object({
-  id: z2.string(),
-  directory: z2.string().optional(),
-  projectID: z2.string().optional(),
-  time: z2.object({ created: z2.number().optional() }).optional()
+var Session = z.object({
+  id: z.string(),
+  directory: z.string().optional(),
+  projectID: z.string().optional(),
+  time: z.object({ created: z.number().optional() }).optional()
 });
-var Project = z2.object({ id: z2.string(), worktree: z2.string().optional() });
+var Project = z.object({ id: z.string(), worktree: z.string().optional() });
 function opencodeRoot(home) {
   if (home) return join15(home, ".local", "share", "opencode");
   return process.env.OPENCODE_DATA_DIR ?? join15(homedir15(), ".local", "share", "opencode");
 }
 async function readJson2(file) {
   try {
-    return JSON.parse(await readFile5(file, "utf8"));
+    return JSON.parse(await readFile6(file, "utf8"));
   } catch {
     return void 0;
   }

package/dist/cli.js

@@ -276,7 +276,7 @@ program.action(async () => {
   const [{ render }, React, { Root }, { Fullscreen }] = await Promise.all([
     import("ink"),
     import("react"),
-    import("./Root-T2V2YHJ2.js"),
+    import("./Root-HZIVZ2YT.js"),
     import("./Fullscreen-GK2ZYXHV.js")
   ]);
   render(React.createElement(Fullscreen, null, React.createElement(Root)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokz/cli",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "See where your coding agents' tokens and dollars actually go.",
   "keywords": [
     "claude",