Release cdxusage 0.1.2 audit fixes

Author: Krablante

README.md

@@ -88,12 +88,8 @@ Default pricing mode is `auto`.
 
 `cdxusage` reads the resolved Codex home's `config.toml`. If it sees
 `service_tier = "priority"` or legacy `service_tier = "fast"`, it applies
-OpenAI priority prices to the Codex models that currently expose priority rates
-in Codex usage:
-
-```text
-gpt-5.4,gpt-5.4-mini,gpt-5.5
-```
+OpenAI priority prices to all OpenAI models that currently expose official
+priority rates.
 
 Force standard pricing:
 
@@ -157,36 +153,27 @@ Intentional differences from `@ccusage/codex`:
 
 ## Benchmarks
 
-Measured on the same local Codex archive and bounded with `nice`, `ionice`, and
-`timeout`.
-
-Controlled largest-file fixture:
-
-| Tool | Scenario | Time | RSS |
-| --- | --- | ---: | ---: |
-| `@ccusage/codex@18.0.11` | largest JSONL | `2.59s` | `823972KB` |
-| `cdxusage` | same file, cold | `0.66s` | `200888KB` |
-| `cdxusage` | same file, warm | `0.07s` | `60996KB` |
+Run the local benchmark helper against your own Codex archive:
 
-Improvements:
-
-- cold: 74.5% faster, 75.6% less RSS
-- warm: 97.3% faster, 92.6% less RSS
+```bash
+npm run benchmark -- --since 2026-05-01 --timeout 25
+```
 
-Token totals and `costUSD` matched upstream exactly on this fixture.
+It runs `cdxusage` cold, `cdxusage` warm, and
+`npx -y @ccusage/codex@latest` with the same date filter. On Linux it also
+captures max RSS through `/usr/bin/time -v`.
 
-Real filtered profile:
+Recent local sanity check on a large Codex archive:
 
 | Tool | Scenario | Time | RSS | Result |
 | --- | --- | ---: | ---: | --- |
-| `@ccusage/codex@18.0.11` | `--since 2026-05-01`, timeout 120s | `120.01s` | n/a | timed out |
-| `cdxusage` | same filter, cold | `4.35s` | `201528KB` | complete |
-| `cdxusage` | same filter, warm | `0.21s` | `92204KB` | complete |
-
-Compared with upstream's bounded timeout, real-profile cold output is at least
-96.4% faster and warm output is at least 99.8% faster. Upstream did not
-complete in the timeout window, so real-profile upstream RSS is not comparable;
-the completed controlled fixture above is the RSS comparison.
+| `@ccusage/codex@18.0.11` | `--since 2026-05-01`, timeout 25s | `>25.01s` | n/a | timed out |
+| `cdxusage` | same filter, cold | `3.63s` | `173784KB` | complete |
+| `cdxusage` | same filter, warm | `0.24s` | `96856KB` | complete |
+
+Compared with upstream's bounded timeout, this run was at least 85.5% faster
+cold and 99.0% faster warm. Upstream did not complete in the timeout window, so
+upstream RSS is not comparable for this real-profile check.
 
 Live pricing status from a fresh check: OpenAI official + bundled fallback,
 `modelCount: 63`. Non-OpenAI routes, if present in local Codex logs, are left

docs/compatibility.md

@@ -137,10 +137,11 @@ length without storing every token event in memory or cache.
 
 Default pricing is `auto`. It reads the resolved Codex home `config.toml` and
 treats `service_tier = "priority"` or legacy `"fast"` as priority pricing.
-Codex logs do not expose per-request service tier, so auto mode prices only
-`gpt-5.4,gpt-5.4-mini,gpt-5.5` as priority by default. Use `--no-priority` or
-`--speed standard` to force non-priority pricing. Use `--priority-models all`
-or a comma-separated list to override the priority scope.
+Codex logs do not expose per-request service tier, so auto mode prices all
+OpenAI models with official priority rates as priority when the resolved config
+sets priority/fast mode. Use `--no-priority` or `--speed standard` to force
+non-priority pricing. Use `--priority-models all` or a comma-separated list to
+override the priority scope.
 
 Non-OpenAI model routes are not estimated. They appear in
 `pricing.missingModels` when `--include-stats` is used.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cdxusage",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Fast Codex usage, token, and estimated cost CLI.",
   "bin": {
@@ -11,13 +11,14 @@
   },
   "scripts": {
     "start": "node ./bin/cdxusage.mjs",
-    "check": "node --check ./bin/cdxusage.mjs && node --check ./src/cli.mjs && node --check ./src/codex-home.mjs && node --check ./src/engine.mjs && node --check ./src/format.mjs && node --check ./src/pricing.mjs && node --check ./src/table.mjs && node --check ./scripts/build-portable.mjs && node --check ./test/smoke.mjs",
+    "check": "node --check ./bin/cdxusage.mjs && node --check ./src/cli.mjs && node --check ./src/codex-home.mjs && node --check ./src/engine.mjs && node --check ./src/format.mjs && node --check ./src/pricing.mjs && node --check ./src/table.mjs && node --check ./scripts/build-portable.mjs && node --check ./scripts/benchmark-local.mjs && node --check ./test/smoke.mjs",
     "lint": "npm run check",
     "typecheck": "npm run check",
     "test": "node ./test/codex-home.test.mjs && node ./test/engine.test.mjs && node ./test/cli.test.mjs && node ./test/pricing.test.mjs",
     "smoke": "node ./test/smoke.mjs",
     "portable:build": "node ./scripts/build-portable.mjs",
-    "portable:smoke": "npm run portable:build && sh ./portable/cdxusage --version && node -e \"const fs=require('fs'); for (const file of ['portable/cdxusage.cmd','portable/cdxusage.ps1','portable/src/codex-home.mjs']) if (!fs.existsSync(file)) process.exit(1)\" && node ./test/smoke.mjs --portable"
+    "portable:smoke": "npm run portable:build && sh ./portable/cdxusage --version && node -e \"const fs=require('fs'); for (const file of ['portable/LICENSE','portable/cdxusage.cmd','portable/cdxusage.ps1','portable/src/codex-home.mjs']) if (!fs.existsSync(file)) process.exit(1)\" && node ./test/smoke.mjs --portable",
+    "benchmark": "node ./scripts/benchmark-local.mjs"
   },
   "files": [
     "bin",

package.json

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(scriptDir, '..');
+const args = parseArgs(process.argv.slice(2));
+const timeoutSeconds = Number(args.timeout ?? 25);
+const since = args.since ?? '2026-05-01';
+const workDir = await mkdtemp(path.join(tmpdir(), 'cdxusage-bench-'));
+
+try {
+  const cacheFile = path.join(workDir, 'index.json');
+  const pricingCacheFile = path.join(workDir, 'pricing.json');
+  const commonCdxArgs = [
+    path.join(repoRoot, 'bin/cdxusage.mjs'),
+    'monthly',
+    '--offline',
+    '--json',
+    '--since',
+    since,
+    '--cache-file',
+    cacheFile,
+    '--pricing-cache-file',
+    pricingCacheFile,
+  ];
+  const rows = [];
+  rows.push(await measure('cdxusage cold', process.execPath, [...commonCdxArgs, '--clear-cache'], timeoutSeconds));
+  rows.push(await measure('cdxusage warm', process.execPath, commonCdxArgs, timeoutSeconds));
+  rows.push(await measure('upstream latest', 'npx', ['-y', '@ccusage/codex@latest', 'monthly', '--since', since, '--json'], timeoutSeconds));
+  printRows(rows);
+} finally {
+  await rm(workDir, { recursive: true, force: true });
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    const [key, inlineValue] = token.split('=', 2);
+    if (key === '--since' || key === '--timeout') {
+      out[key.slice(2)] = inlineValue ?? argv[++index];
+    }
+  }
+  return out;
+}
+
+async function measure(label, command, commandArgs, timeoutSeconds) {
+  const start = process.hrtime.bigint();
+  const hasTime = process.platform !== 'win32';
+  const finalCommand = hasTime ? '/usr/bin/time' : command;
+  const finalArgs = hasTime
+    ? ['-v', 'timeout', `${timeoutSeconds}s`, command, ...commandArgs]
+    : commandArgs;
+  const result = await run(finalCommand, finalArgs);
+  const wallSeconds = Number(process.hrtime.bigint() - start) / 1_000_000_000;
+  const maxRssKb = parseMaxRss(result.stderr);
+  return {
+    label,
+    status: result.status,
+    timedOut: result.status === 124,
+    wallSeconds,
+    maxRssKb,
+  };
+}
+
+function run(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { cwd: repoRoot, stdio: ['ignore', 'ignore', 'pipe'] });
+    let stderr = '';
+    child.stderr.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk;
+    });
+    child.on('close', (status) => resolve({ status, stderr }));
+  });
+}
+
+function parseMaxRss(stderr) {
+  const match = stderr.match(/Maximum resident set size \(kbytes\):\s*(\d+)/);
+  return match ? Number(match[1]) : null;
+}
+
+function printRows(rows) {
+  console.log('| Tool | Time | RSS | Result |');
+  console.log('| --- | ---: | ---: | --- |');
+  for (const row of rows) {
+    const time = row.timedOut ? `>${row.wallSeconds.toFixed(2)}s` : `${row.wallSeconds.toFixed(2)}s`;
+    const rss = row.maxRssKb == null ? 'n/a' : `${row.maxRssKb}KB`;
+    const result = row.timedOut ? `timed out (${row.status})` : row.status === 0 ? 'complete' : `exit ${row.status}`;
+    console.log(`| ${row.label} | ${time} | ${rss} | ${result} |`);
+  }
+}

scripts/benchmark-local.mjs

@@ -5,10 +5,29 @@ import { collectUsage, defaultCacheFile, normalizeDate, safeTimeZone } from './e
 import { DEFAULT_LOCALE, DEFAULT_TIMEZONE, formatDisplayDate, formatDisplayMonth, toPublicModels, toPublicUsage } from './format.mjs';
 import { renderReportTable } from './table.mjs';
 
-export const VERSION = '0.1.1';
+export const VERSION = '0.1.2';
 
 const COMMANDS = new Set(['daily', 'monthly', 'session', 'sessions']);
-const DEFAULT_AUTO_PRIORITY_MODELS = Object.freeze(['gpt-5.4', 'gpt-5.4-mini', 'gpt-5.5']);
+const DEFAULT_AUTO_PRIORITY_MODELS = null;
+const LONG_OPTIONS_WITH_VALUES = new Set([
+  '--since',
+  '--until',
+  '--timezone',
+  '--locale',
+  '--codex-home',
+  '--sessions-dir',
+  '--cache-file',
+  '--pricing-cache-file',
+  '--pricing-ttl-hours',
+  '--pricing-fetch-timeout-ms',
+  '--max-cache-bytes',
+  '--discovery',
+  '--discovery-mode',
+  '--speed',
+  '--priority-models',
+  '--sort',
+  '--order',
+]);
 
 export async function main(argv = process.argv.slice(2), io = { stdout: process.stdout, stderr: process.stderr }) {
   let args;
@@ -117,7 +136,12 @@ export function parseArgs(argv) {
     args.commandSpecified = true;
   }
   while (rest.length > 0) {
-    const token = rest.shift();
+    let token = rest.shift();
+    const expanded = splitLongOptionValue(token);
+    if (expanded) {
+      token = expanded.option;
+      rest.unshift(expanded.value);
+    }
     switch (token) {
       case '-h':
       case '--help':
@@ -480,6 +504,21 @@ function requireValue(option, rest) {
   return value;
 }
 
+function splitLongOptionValue(token) {
+  if (!token?.startsWith('--')) {
+    return null;
+  }
+  const separatorIndex = token.indexOf('=');
+  if (separatorIndex < 0) {
+    return null;
+  }
+  const option = token.slice(0, separatorIndex);
+  if (!LONG_OPTIONS_WITH_VALUES.has(option)) {
+    return null;
+  }
+  return { option, value: token.slice(separatorIndex + 1) };
+}
+
 function helpText(command) {
   if (!command) {
     return topLevelHelp();

src/cli.mjs

@@ -15,7 +15,6 @@ const TURN_NEEDLE = Buffer.from('turn_context');
 const MODEL_RE = /"model"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/;
 const FIND_FIELD_SEPARATOR = '\x1f';
 const FIND_RECORD_SEPARATOR = '\x1e';
-const PRUNE_SAFETY_MS = 48 * 60 * 60 * 1000;
 const DEFAULT_MAX_CACHE_BYTES = 64 * 1024 * 1024;
 
 export function defaultCacheFile() {
@@ -30,7 +29,8 @@ export async function collectUsage(options = {}) {
   const timezone = safeTimeZone(options.timezone);
   const since = normalizeDate(options.since);
   const until = normalizeDate(options.until);
-  const pruneBeforeMs = since ? Date.parse(`${since}T00:00:00.000Z`) - PRUNE_SAFETY_MS : undefined;
+  const pruneBeforeDate = since ? addDaysToDateKey(since, -2) : undefined;
+  const pruneAfterDate = until ? addDaysToDateKey(until, 2) : undefined;
   const cacheFile = options.cacheFile ?? defaultCacheFile();
   const useCache = options.useCache !== false;
   const saveCache = useCache && options.saveCache !== false;
@@ -69,17 +69,17 @@ export async function collectUsage(options = {}) {
     stats.filesSeen += 1;
     stats.bytesSeen += st.size;
 
-    if (pruneBeforeMs !== undefined && st.mtimeMs < pruneBeforeMs) {
-      stats.filesSkippedByMtime += 1;
-      stats.bytesSkippedByMtime += st.size;
+    const sessionInfo = makeSessionInfo(file, sessionsDir);
+    if (shouldSkipBySessionPathDate(sessionInfo.directory, pruneBeforeDate, pruneAfterDate)) {
+      stats.filesSkippedByPathDate += 1;
+      stats.bytesSkippedByPathDate += st.size;
       const oldEntry = useCache ? cache.files[file] : undefined;
       if (oldEntry && sameFile(st, oldEntry)) {
         nextFiles[file] = oldEntry;
       }
       continue;
     }
 
-    const sessionInfo = makeSessionInfo(file, sessionsDir);
     const oldEntry = useCache ? cache.files[file] : undefined;
     let entry;
 
@@ -604,7 +604,7 @@ function buildReport(aggregate, stats, nextFiles) {
     addUsage(totals, day);
   }
 
-  const filesEligibleForCache = stats.filesSeen - stats.filesSkippedByMtime;
+  const filesEligibleForCache = stats.filesSeen - stats.filesSkippedByMtime - stats.filesSkippedByPathDate;
   return {
     daily,
     monthly,
@@ -776,6 +776,7 @@ function createStats(cache, timezone, billingThresholds = DEFAULT_BILLING_THRESH
     billingThresholds,
     filesSeen: 0,
     filesSkippedByMtime: 0,
+    filesSkippedByPathDate: 0,
     filesFromCache: 0,
     filesScannedFull: 0,
     filesScannedTail: 0,
@@ -787,6 +788,7 @@ function createStats(cache, timezone, billingThresholds = DEFAULT_BILLING_THRESH
     bytesSeen: 0,
     bytesRead: 0,
     bytesSkippedByMtime: 0,
+    bytesSkippedByPathDate: 0,
     bytesSkippedByCache: 0,
     bytesSkippedByTailCache: 0,
     cacheEntriesLoaded: Object.keys(cache.files).length,
@@ -867,9 +869,45 @@ export function isWithinRange(dateKey, since, until) {
   return true;
 }
 
+function shouldSkipBySessionPathDate(directory, pruneBeforeDate, pruneAfterDate) {
+  if (!pruneBeforeDate && !pruneAfterDate) {
+    return false;
+  }
+  const dateKey = sessionPathDateKey(directory);
+  if (!dateKey) {
+    return false;
+  }
+  if (pruneBeforeDate && dateKey < pruneBeforeDate) {
+    return true;
+  }
+  if (pruneAfterDate && dateKey > pruneAfterDate) {
+    return true;
+  }
+  return false;
+}
+
+function sessionPathDateKey(directory) {
+  const match = String(directory).match(/(?:^|\/)(\d{4})\/(\d{2})\/(\d{2})(?:\/|$)/);
+  if (!match) {
+    return null;
+  }
+  const dateKey = `${match[1]}-${match[2]}-${match[3]}`;
+  try {
+    return normalizeDate(dateKey);
+  } catch {
+    return null;
+  }
+}
+
+function addDaysToDateKey(dateKey, days) {
+  const [year, month, day] = dateKey.split('-').map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day + days));
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}`;
+}
+
 export function safeTimeZone(timezone) {
   if (timezone == null || String(timezone).trim() === '') {
-    return Intl.DateTimeFormat().resolvedOptions().timeZone ?? 'UTC';
+    return 'UTC';
   }
   try {
     Intl.DateTimeFormat('en-US', { timeZone: timezone });