@iislee/opencodex 2.11.0 → 2.31.0

package/src/usage/summary.ts

@@ -1,8 +1,8 @@
 import { baseProviderLabel } from "../providers/label";
 import { canonicalAntigravityUsageModel } from "../providers/antigravity-models";
 import { usageDisplayTotalTokens } from "./totals";
-import type { PersistedUsageEntry, UsageStatus } from "./log";
-import { estimateComboCost, estimateRequestCost, effectiveServiceTier } from "./cost";
+import { isCodexUsageAccountLogLabel, type PersistedUsageEntry, type UsageStatus } from "./log";
+import { estimateAttemptCost, estimateComboCost, estimateRequestCost, serviceTierContext } from "./cost";
 
 export type UsageRange = "7d" | "30d" | "all";
 export type UsageSurface = "all" | "codex" | "claude" | "grok";
@@ -79,6 +79,28 @@ export interface UsageProvider {
   estimatedCostUsd?: number;
 }
 
+export interface UsageAccount {
+  accountLogLabel: string;
+  ambiguous: boolean;
+  requests: number;
+  attemptCount: number;
+  measuredAttempts: number;
+  reportedAttempts: number;
+  estimatedAttempts: number;
+  unmeteredAttempts: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadInputTokens: number;
+  cacheCreationInputTokens: number;
+  reasoningOutputTokens: number;
+  totalTokens: number;
+  usageCoverageRatio: number;
+  estimatedCostUsd?: number;
+  pricedAttempts: number;
+  unpricedAttempts: number;
+  priceCoverageRatio: number;
+}
+
 export interface UsageSummary {
   range: UsageRange;
   surface: UsageSurface;
@@ -88,6 +110,7 @@ export interface UsageSummary {
   days: UsageDay[];
   models: UsageModel[];
   providers: UsageProvider[];
+  accounts: UsageAccount[];
 }
 
 const DAY_MS = 86_400_000;
@@ -113,9 +136,23 @@ export function parseUsageSurface(input: string | null | undefined): UsageSurfac
   return "all";
 }
 
-function rangeWindow(range: UsageRange, now: number): { since: number | null; days: number } {
-  if (range === "7d") return { since: now - 7 * DAY_MS, days: 7 };
-  if (range === "30d") return { since: now - 30 * DAY_MS, days: 30 };
+function startOfLocalDay(ts: number): number {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+export function rangeWindow(range: UsageRange, now: number): { since: number | null; days: number } {
+  if (range === "7d") {
+    const start = new Date(startOfLocalDay(now));
+    start.setDate(start.getDate() - 6);
+    return { since: start.getTime(), days: 7 };
+  }
+  if (range === "30d") {
+    const start = new Date(startOfLocalDay(now));
+    start.setDate(start.getDate() - 29);
+    return { since: start.getTime(), days: 30 };
+  }
   return { since: null, days: 0 };
 }
 
@@ -286,7 +323,7 @@ function addEstimatedCost(
     totals.unmeteredRequests += 1;
     return;
   }
-  const tier = effectiveServiceTier(entry);
+  const tier = serviceTierContext(entry);
   const estimate = entry.attempts?.length
     ? estimateComboCost(entry.attempts, undefined, tier)
     : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
@@ -324,8 +361,11 @@ function buildDayGrid(range: UsageRange, since: number | null, now: number, entr
     m.attemptCount += 1;
     m.totalTokens += usageDisplayTotalTokens(attribution.usage, attribution.totalTokens) ?? 0;
   };
+  const startOfToday = startOfLocalDay(now);
   for (let i = days - 1; i >= 0; i--) {
-    const key = localDateKey(now - i * DAY_MS);
+    const d = new Date(startOfToday);
+    d.setDate(d.getDate() - i);
+    const key = localDateKey(d.getTime());
     grid.set(key, { date: key, requests: 0, measuredRequests: 0, reportedRequests: 0, totalTokens: 0, models: [] });
   }
   for (const entry of entries) {
@@ -415,7 +455,7 @@ function buildModels(entries: PersistedUsageEntry[], totalTokens: number): Usage
   }
   // Accumulate per-model estimated cost
   for (const entry of entries) {
-    const tier = effectiveServiceTier(entry);
+    const tier = serviceTierContext(entry);
     const estimate = entry.attempts?.length
       ? estimateComboCost(entry.attempts, undefined, tier)
       : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
@@ -524,7 +564,7 @@ function buildProviders(entries: PersistedUsageEntry[], totalTokens: number): Us
     }
   }
   for (const entry of entries) {
-    const tier = effectiveServiceTier(entry);
+    const tier = serviceTierContext(entry);
     const estimate = entry.attempts?.length
       ? estimateComboCost(entry.attempts, undefined, tier)
       : estimateRequestCost({ provider: entry.provider, model: entry.model, usage: entry.usage, usageStatus: entry.usageStatus, serviceTier: tier });
@@ -547,6 +587,133 @@ function buildProviders(entries: PersistedUsageEntry[], totalTokens: number): Us
   return providers.sort((a, b) => b.requests - a.requests);
 }
 
+const LEGACY_AMBIGUOUS_ACCOUNT_LABEL = "legacy-ambiguous";
+
+function legacyCodexAccountLabel(provider: string): string | null {
+  if (baseProviderLabel(provider) !== "openai") return null;
+  const suffix = provider.match(/-(main|p[a-f0-9]{6})$/)?.[1];
+  return suffix ?? LEGACY_AMBIGUOUS_ACCOUNT_LABEL;
+}
+
+function accountLabelForAttribution(provider: string, explicit: unknown): string | null {
+  if (isCodexUsageAccountLogLabel(explicit)) return explicit;
+  return legacyCodexAccountLabel(provider);
+}
+
+function buildAccounts(entries: PersistedUsageEntry[]): UsageAccount[] {
+  const byLabel = new Map<string, UsageAccount>();
+  const requestIds = new Map<string, Set<string>>();
+
+  const add = (input: {
+    requestId: string;
+    provider: string;
+    accountLogLabel?: string;
+    usageStatus: UsageStatus;
+    usage?: PersistedUsageEntry["usage"];
+    totalTokens?: number;
+    estimate: ReturnType<typeof estimateRequestCost>;
+  }): void => {
+    const label = accountLabelForAttribution(input.provider, input.accountLogLabel);
+    if (!label) return;
+    let row = byLabel.get(label);
+    if (!row) {
+      row = {
+        accountLogLabel: label,
+        ambiguous: label === LEGACY_AMBIGUOUS_ACCOUNT_LABEL,
+        requests: 0,
+        attemptCount: 0,
+        measuredAttempts: 0,
+        reportedAttempts: 0,
+        estimatedAttempts: 0,
+        unmeteredAttempts: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheReadInputTokens: 0,
+        cacheCreationInputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0,
+        usageCoverageRatio: 0,
+        pricedAttempts: 0,
+        unpricedAttempts: 0,
+        priceCoverageRatio: 0,
+      };
+      byLabel.set(label, row);
+      requestIds.set(label, new Set());
+    }
+    requestIds.get(label)!.add(input.requestId);
+    row.requests = requestIds.get(label)!.size;
+    row.attemptCount += 1;
+    const measured = input.usage !== undefined && isMeasuredStatus(input.usageStatus);
+    if (!measured) {
+      row.unmeteredAttempts += 1;
+      return;
+    }
+
+    row.measuredAttempts += 1;
+    if (input.usageStatus === "reported") row.reportedAttempts += 1;
+    else if (input.usageStatus === "estimated") row.estimatedAttempts += 1;
+    row.inputTokens += input.usage!.inputTokens;
+    row.outputTokens += input.usage!.outputTokens;
+    const creation = input.usage!.cacheCreationInputTokens;
+    const read = typeof input.usage!.cacheReadInputTokens === "number"
+      ? input.usage!.cacheReadInputTokens
+      : typeof input.usage!.cachedInputTokens === "number" && typeof creation === "number"
+        ? Math.max(0, input.usage!.cachedInputTokens - creation)
+        : input.usage!.cachedInputTokens;
+    if (typeof read === "number") row.cacheReadInputTokens += read;
+    if (typeof creation === "number") row.cacheCreationInputTokens += creation;
+    if (typeof input.usage!.reasoningOutputTokens === "number") {
+      row.reasoningOutputTokens += input.usage!.reasoningOutputTokens;
+    }
+    row.totalTokens += usageDisplayTotalTokens(input.usage, input.totalTokens) ?? 0;
+    if (input.estimate) {
+      row.pricedAttempts += 1;
+      row.estimatedCostUsd = (row.estimatedCostUsd ?? 0) + input.estimate.cost.total;
+    } else {
+      row.unpricedAttempts += 1;
+    }
+  };
+
+  for (const entry of entries) {
+    const tier = serviceTierContext(entry);
+    if (entry.attempts?.length) {
+      for (const attempt of entry.attempts) {
+        add({
+          requestId: entry.requestId,
+          provider: attempt.provider,
+          ...(attempt.accountLogLabel ? { accountLogLabel: attempt.accountLogLabel } : {}),
+          usageStatus: attempt.usageStatus,
+          ...(attempt.usage ? { usage: attempt.usage } : {}),
+          ...(attempt.totalTokens !== undefined ? { totalTokens: attempt.totalTokens } : {}),
+          estimate: estimateAttemptCost(attempt, undefined, tier),
+        });
+      }
+      continue;
+    }
+    add({
+      requestId: entry.requestId,
+      provider: entry.provider,
+      ...(entry.accountLogLabel ? { accountLogLabel: entry.accountLogLabel } : {}),
+      usageStatus: entry.usageStatus,
+      ...(entry.usage ? { usage: entry.usage } : {}),
+      ...(entry.totalTokens !== undefined ? { totalTokens: entry.totalTokens } : {}),
+      estimate: estimateRequestCost({
+        provider: entry.provider,
+        model: entry.model,
+        usage: entry.usage,
+        usageStatus: entry.usageStatus,
+        serviceTier: tier,
+      }),
+    });
+  }
+
+  for (const row of byLabel.values()) {
+    row.usageCoverageRatio = row.attemptCount === 0 ? 0 : row.measuredAttempts / row.attemptCount;
+    row.priceCoverageRatio = row.measuredAttempts === 0 ? 0 : row.pricedAttempts / row.measuredAttempts;
+  }
+  return [...byLabel.values()].sort((a, b) => b.totalTokens - a.totalTokens);
+}
+
 export function summarizeUsage(
   entries: PersistedUsageEntry[],
   range: UsageRange,
@@ -581,5 +748,6 @@ export function summarizeUsage(
     days: buildDayGrid(range, since, now, filteredEntries),
     models: buildModels(filteredEntries, totals.totalTokens),
     providers: buildProviders(filteredEntries, totals.totalTokens),
+    accounts: buildAccounts(filteredEntries),
   };
 }

package/src/usage/user-cost-overlay-reconciler.ts

@@ -0,0 +1,313 @@
+/**
+ * Cross-process reconciliation for user cost overlays.
+ *
+ * `refreshUserCostOverlays` is process-local by design: `ocx config set`
+ * executes `saveConfig()` in the CLI process, and a direct `config.json` edit
+ * runs no in-process code at all. A running proxy therefore keeps its previous
+ * `activeUserCostOverlays()`/version until restart or another in-process
+ * refresh.
+ *
+ * This module gives the long-lived server a lightweight stat-based poller:
+ * when `config.json` changes on disk, it re-reads the persisted config, mirrors
+ * the disk `modelCosts` rows into the live provider rows (so a later in-process
+ * save cannot erase the external edit), and refreshes the overlay registry so
+ * Logs/Usage estimates follow the edit without a restart.
+ *
+ * The reconciler is owner-scoped: every `startServer` acquires its own lease
+ * (with its own live config), and the shared timer is torn down only when the
+ * LAST owner stops. This mirrors `acquireServerBackgroundLifecycle` so stopping
+ * one of several servers cannot kill reconciliation for the others.
+ */
+import { statSync } from "node:fs";
+
+import { getConfigPath, readConfigDiagnostics } from "../config";
+import type { OcxConfig, OcxProviderConfig } from "../types";
+import {
+  refreshPreservedProviderOwner,
+  refreshUserCostOverlays,
+  registerPreservedProviderOwner,
+  setPreservedDiskOnlyProviders,
+  unregisterPreservedProviderOwner,
+} from "./user-cost-overlays";
+
+/** Default poll cadence for external config edits. */
+export const USER_COST_OVERLAY_RECONCILE_INTERVAL_MS = 5_000;
+
+let reconcileTimer: ReturnType<typeof setInterval> | null = null;
+let reconcileTimerMs = 0;
+const owners = new Map<symbol, OcxConfig | null>();
+const ownerIntervals = new Map<symbol, number>();
+let lastStamp: { mtimeMs: number; size: number; ctimeMs: number; ino: number } | null = null;
+let invalidReconcileCount = 0;
+
+function configStamp(): { mtimeMs: number; size: number; ctimeMs: number; ino: number } | null {
+  try {
+    const stat = statSync(getConfigPath());
+    return {
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      ctimeMs: stat.ctimeMs,
+      ino: Number(stat.ino),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Registered live configs plus an optional one-shot config, deduped by object identity. */
+function liveConfigsForPreservation(extra?: OcxConfig | null): OcxConfig[] {
+  const liveConfigs: OcxConfig[] = [];
+  const seen = new Set<OcxConfig>();
+  if (extra) {
+    seen.add(extra);
+    liveConfigs.push(extra);
+  }
+  for (const config of owners.values()) {
+    if (!config || seen.has(config)) continue;
+    seen.add(config);
+    liveConfigs.push(config);
+  }
+  return liveConfigs;
+}
+
+/**
+ * Mirror disk `modelCosts` rows into provider rows the live config already
+ * knows. Providers added by the external edit are left out of the live config
+ * (they would change the routing surface); their overlays still become active
+ * because the registry below is refreshed from the disk config.
+ */
+function adoptDiskModelCosts(live: OcxConfig, disk: OcxConfig): void {
+  if (!live.providers || !disk.providers) return;
+  for (const [name, diskProvider] of Object.entries(disk.providers)) {
+    const liveProvider = live.providers[name];
+    if (!liveProvider) continue;
+    if (diskProvider?.modelCosts === undefined) {
+      delete liveProvider.modelCosts;
+    } else {
+      liveProvider.modelCosts = structuredClone(diskProvider.modelCosts);
+    }
+  }
+}
+
+/**
+ * Remember provider rows present on disk that at least one live routing
+ * config does NOT own. They stay out of the live configs that lack them
+ * (adding them would change the routing surface), but
+ * `persistConfigUnlocked` merges them back at serialization so ANY owner's
+ * unrelated save preserves a provider row that another active owner owns.
+ *
+ * A row is preserved when it is missing from at least one live config: the
+ * writer that lacks it would otherwise erase it. Rows every live config owns
+ * need no protection because every writer carries them from its own config.
+ */
+function rememberDiskOnlyProviders(liveConfigs: readonly OcxConfig[], disk: OcxConfig): void {
+  const preserved: Record<string, OcxProviderConfig> = {};
+  if (disk.providers && liveConfigs.length > 0) {
+    for (const [name, provider] of Object.entries(disk.providers)) {
+      if (!provider) continue;
+      const ownedByAll = liveConfigs.every(live => Object.hasOwn(live.providers ?? {}, name));
+      if (!ownedByAll) preserved[name] = structuredClone(provider);
+    }
+  }
+  setPreservedDiskOnlyProviders(Object.keys(preserved).length > 0 ? preserved : null);
+  // Update only registered server owners. One-shot callers without a lease do
+  // not become deletion authorities merely by asking for a reconciliation.
+  for (const live of liveConfigs) refreshPreservedProviderOwner(live, disk);
+}
+
+/**
+ * Re-read the persisted config and recompute the disk-only provider
+ * preservation registry against the CURRENT owner set. Used when an owner
+ * stops but others remain: a newer owner may have owned a provider that an
+ * older owner still treats as disk-only, and the registry must reflect the
+ * remaining owners rather than the stale pre-stop snapshot.
+ *
+ * A missing or transiently invalid file leaves the registry untouched so a
+ * bad write cannot erase preservation state.
+ */
+function recomputePreservedDiskOnlyProviders(): void {
+  const diagnostics = readConfigDiagnostics();
+  if (diagnostics.source !== "file") return;
+  const liveConfigs = liveConfigsForPreservation();
+  if (liveConfigs.length > 0) {
+    rememberDiskOnlyProviders(liveConfigs, diagnostics.config);
+  } else {
+    // No live routing configuration remains to protect disk-only providers;
+    // clear the cache so a later save cannot resurrect externally deleted rows.
+    setPreservedDiskOnlyProviders(null);
+  }
+}
+
+/**
+ * Re-read the persisted config and make external overlay edits live.
+ *
+ * Returns `false` (and leaves the registry untouched) when the file is missing
+ * or invalid, so a transient bad write cannot wipe display-only prices.
+ */
+export function reconcileUserCostOverlaysFromDisk(liveConfig?: OcxConfig | null): boolean {
+  const diagnostics = readConfigDiagnostics();
+  if (diagnostics.source !== "file") return false;
+  const disk = diagnostics.config;
+  if (liveConfig) {
+    adoptDiskModelCosts(liveConfig, disk);
+    // A one-shot caller is not the whole process. Existing server owners still
+    // participate in global preservation or this call can drop protection for
+    // a provider absent from an older live projection.
+    rememberDiskOnlyProviders(liveConfigsForPreservation(liveConfig), disk);
+  } else {
+    // No live routing config was supplied: mirror the owners path so a stale
+    // preservation registry cannot resurrect externally deleted providers on
+    // the next saveConfig. Registered owners still protect disk-only rows;
+    // without any, preservation is cleared.
+    const liveConfigs = liveConfigsForPreservation();
+    if (liveConfigs.length > 0) {
+      for (const live of liveConfigs) adoptDiskModelCosts(live, disk);
+      rememberDiskOnlyProviders(liveConfigs, disk);
+    } else {
+      setPreservedDiskOnlyProviders(null);
+    }
+  }
+  // Refresh from the DISK config: overlays for providers only added by the
+  // external edit are display-only and must still resolve for historical rows.
+  refreshUserCostOverlays(disk);
+  return true;
+}
+
+function reconcileForOwners(): void {
+  const diagnostics = readConfigDiagnostics();
+  if (diagnostics.source !== "file") {
+    if (diagnostics.source === "fallback") invalidReconcileCount += 1;
+    return;
+  }
+  const disk = diagnostics.config;
+  const liveConfigs = liveConfigsForPreservation();
+  if (liveConfigs.length > 0) {
+    for (const live of liveConfigs) adoptDiskModelCosts(live, disk);
+    rememberDiskOnlyProviders(liveConfigs, disk);
+  } else {
+    // Overlay-only refresh with no live routing configuration: do not treat
+    // every disk provider as protected, and do not let a stale preservation
+    // cache resurrect providers that were intentionally removed.
+    setPreservedDiskOnlyProviders(null);
+  }
+  refreshUserCostOverlays(disk);
+}
+
+/** Test-only observation that proves the timer actually read an invalid config fallback. */
+export function userCostOverlayInvalidReconcileCountForTests(): number {
+  return invalidReconcileCount;
+}
+
+/** Smallest poll interval across all active owners (the effective cadence). */
+function effectiveIntervalMs(): number {
+  let min = Number.POSITIVE_INFINITY;
+  for (const interval of ownerIntervals.values()) {
+    if (interval < min) min = interval;
+  }
+  return min === Number.POSITIVE_INFINITY ? USER_COST_OVERLAY_RECONCILE_INTERVAL_MS : min;
+}
+
+/**
+ * Keep the shared timer on the effective minimum cadence across owners. A
+ * later owner may request a smaller interval, which restarts the timer; when
+ * an owner stops, the cadence relaxes back up to the smallest still-active
+ * owner's request. The timer therefore never outlives or ignores an owner's
+ * faster polling need, and never polls faster than the active set requires.
+ */
+function syncReconcileTimer(): void {
+  const intervalMs = effectiveIntervalMs();
+  if (reconcileTimer && reconcileTimerMs === intervalMs) return;
+  if (reconcileTimer) clearInterval(reconcileTimer);
+  reconcileTimer = setInterval(() => {
+    const stamp = configStamp();
+    if (!stamp) return;
+    if (
+      lastStamp
+      && lastStamp.mtimeMs === stamp.mtimeMs
+      && lastStamp.size === stamp.size
+      && lastStamp.ctimeMs === stamp.ctimeMs
+      && lastStamp.ino === stamp.ino
+    ) return;
+    lastStamp = stamp;
+    try {
+      reconcileForOwners();
+    } catch {
+      // Display-only reconciliation must never take the proxy down.
+    }
+  }, intervalMs);
+  reconcileTimer.unref?.();
+  reconcileTimerMs = intervalMs;
+}
+
+/**
+ * Start the stat-based reconciler. Each call registers an owner lease; the
+ * shared timer starts with the first owner and stops when the last owner's
+ * `stop()` releases it.
+ */
+export function startUserCostOverlayReconciler(
+  options: { intervalMs?: number; liveConfig?: OcxConfig | null } = {},
+): { stop(): void } {
+  const token = Symbol("user-cost-overlay-reconciler");
+  const liveConfig = options.liveConfig ?? null;
+  owners.set(token, liveConfig);
+  ownerIntervals.set(token, options.intervalMs ?? USER_COST_OVERLAY_RECONCILE_INTERVAL_MS);
+  if (liveConfig) registerPreservedProviderOwner(liveConfig);
+  syncReconcileTimer();
+  return {
+    stop() {
+      const ownedConfig = owners.get(token) ?? null;
+      owners.delete(token);
+      ownerIntervals.delete(token);
+      if (ownedConfig) unregisterPreservedProviderOwner(ownedConfig);
+      if (owners.size === 0) {
+        if (reconcileTimer) clearInterval(reconcileTimer);
+        reconcileTimer = null;
+        reconcileTimerMs = 0;
+        lastStamp = null;
+        // No live routing config remains, so nothing can keep disk-only
+        // providers alive: clear the cache to prevent a later save from
+        // resurrecting an externally deleted provider.
+        setPreservedDiskOnlyProviders(null);
+        return;
+      }
+      syncReconcileTimer();
+      // Other owners remain: recompute preservation against their live
+      // configs. A newer owner may have owned providers that an older owner
+      // still sees as disk-only; without this recompute the older owner's next
+      // unrelated save could erase them.
+      try {
+        recomputePreservedDiskOnlyProviders();
+      } catch {
+        // Preservation is display-only; a failed recompute must not break stop.
+      }
+    },
+  };
+}
+
+/**
+ * Process-wide stop: releases EVERY owner's lease and the shared timer.
+ * Intended for tests and full process teardown. A per-server shutdown must
+ * call its own owner-scoped `stop()` handle instead — this function would
+ * otherwise tear down reconciliation (and disk-only preservation) for every
+ * other server still running in the same process.
+ */
+export function stopUserCostOverlayReconciler(): void {
+  for (const config of owners.values()) {
+    if (config) unregisterPreservedProviderOwner(config);
+  }
+  owners.clear();
+  ownerIntervals.clear();
+  if (reconcileTimer) clearInterval(reconcileTimer);
+  reconcileTimer = null;
+  reconcileTimerMs = 0;
+  lastStamp = null;
+  // No live routing config remains; drop preservation so a later save cannot
+  // resurrect externally deleted providers.
+  setPreservedDiskOnlyProviders(null);
+}
+
+/** Test-only reset for module-global reconciler state. */
+export function resetUserCostOverlayReconcilerForTests(): void {
+  stopUserCostOverlayReconciler();
+  invalidReconcileCount = 0;
+}