tokmon 0.28.1 → 0.28.3

package/dist/{chunk-CVKCVHS7.js → chunk-CFKUZCMB.js}

@@ -5,7 +5,7 @@ import {
   envDir,
   expandHome,
   isValidTimezone
-} from "./chunk-HP5UZCXP.js";
+} from "./chunk-HNWEJ6MS.js";
 
 // src/async.ts
 var DEFAULT_TIMEOUT_MS = 3e4;
@@ -20,13 +20,6 @@ function withTimeout(promise, ms = DEFAULT_TIMEOUT_MS) {
   });
 }
 
-// src/providers/usage-core.ts
-import { readFileSync, readdirSync } from "fs";
-import { readdir as readdir2 } from "fs/promises";
-import { dirname, join as join2, relative } from "path";
-import { createHash as createHash2 } from "crypto";
-import { fileURLToPath } from "url";
-
 // src/tz.ts
 function systemTimezone() {
   try {
@@ -120,14 +113,17 @@ function startOfWeek(ts, tz) {
   const offset = p.weekday === 0 ? 6 : p.weekday - 1;
   return instantFromTz(p.y, p.m, p.d - offset, 0, 0, 0, tz);
 }
-function monthsAgoStart(ts, months, tz) {
-  const p = tzParts(ts, tz);
-  return instantFromTz(p.y, p.m - months, 1, 0, 0, 0, tz);
-}
 function weekKey(ts, tz) {
   return dayKey(startOfWeek(ts, tz), tz);
 }
 
+// src/providers/usage-core.ts
+import { readFileSync, readdirSync } from "fs";
+import { readdir as readdir2 } from "fs/promises";
+import { dirname, join as join2, relative } from "path";
+import { createHash as createHash2 } from "crypto";
+import { fileURLToPath } from "url";
+
 // src/providers/_shared/metric.ts
 var finite = (value, fallback = 0) => typeof value === "number" && Number.isFinite(value) ? value : fallback;
 var finiteNumber = (value) => typeof value === "number" && Number.isFinite(value);
@@ -395,7 +391,7 @@ async function mapLimit(items, limit, fn) {
 }
 
 // src/providers/usage-core.ts
-var SPARK_DAYS = 14;
+var SPARK_DAYS = 30;
 var DAY_MS = 864e5;
 var PRUNE_AGE_MS = 230 * DAY_MS;
 var stores = /* @__PURE__ */ new Map();
@@ -560,8 +556,8 @@ function dashboardSince(tz) {
   const now = Date.now();
   return Math.min(startOfMonth(now, tz), startOfWeek(now, tz), now - SPARK_DAYS * DAY_MS);
 }
-function tableSince(tz) {
-  return monthsAgoStart(Date.now(), 6, tz);
+function tableSince(_tz) {
+  return 0;
 }
 function cleanEntry(e) {
   return {
@@ -596,6 +592,7 @@ function summarize(entries, tz) {
   const byDay = /* @__PURE__ */ new Map();
   let oldestToday = now;
   let hadToday = false;
+  let lastActivityAt = null;
   const add = (s, e) => {
     s.cost += e.cost;
     s.tokens += e.input + e.output + e.cacheCreate + e.cacheRead;
@@ -605,6 +602,9 @@ function summarize(entries, tz) {
   };
   for (const raw of entries) {
     const e = cleanEntry(raw);
+    if (e.ts > 0 && (lastActivityAt === null || e.ts > lastActivityAt)) {
+      lastActivityAt = Math.floor(e.ts);
+    }
     if (e.ts >= monthStart) add(month, e);
     if (e.ts >= weekStart) add(week, e);
     if (e.ts >= todayStart) {
@@ -619,7 +619,7 @@ function summarize(entries, tz) {
   const rawBurnRate = hadToday ? today.cost / hrs : 0;
   const burnRate = Number.isFinite(rawBurnRate) ? rawBurnRate : 0;
   const series = lastDayKeys(now, tz, SPARK_DAYS).map((k) => byDay.get(k) ?? 0);
-  return { today, week, month, burnRate, series };
+  return { today, week, month, burnRate, series, lastActivityAt };
 }
 function groupBy(entries, keyFn) {
   const groups = /* @__PURE__ */ new Map();
@@ -739,243 +739,6 @@ function coalesceTables(list) {
   return mergeTables(list);
 }
 
-// src/rpc/contract.ts
-import { Schema } from "effect";
-import * as Rpc from "effect/unstable/rpc/Rpc";
-import * as RpcGroup from "effect/unstable/rpc/RpcGroup";
-var TOKMON_WS_PATH = "/ws";
-var TOKMON_PROTOCOL_VERSION = 3;
-var TOKMON_CAPABILITIES = ["config-cas", "config-revision", "allowed-hosts"];
-var TOKMON_WS_METHODS = {
-  getConfig: "tokmon.getConfig",
-  setConfig: "tokmon.setConfig",
-  refresh: "tokmon.refresh",
-  browseFs: "tokmon.browseFs",
-  snapshot: "tokmon.snapshot",
-  config: "tokmon.config"
-};
-var RefreshScopeSchema = Schema.Literals([
-  "all",
-  "summary",
-  "table",
-  "billing",
-  "peak"
-]);
-var ProviderIdSchema = Schema.Literals(PROVIDER_IDS);
-var NonNegativeIntegerSchema = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-var PositiveFiniteSchema = Schema.Finite.check(Schema.isGreaterThanOrEqualTo(1));
-var AccountSchema = Schema.Struct({
-  id: Schema.String,
-  providerId: ProviderIdSchema,
-  name: Schema.String,
-  homeDir: Schema.String,
-  color: Schema.optionalKey(Schema.String)
-});
-var ConfigSchema = Schema.Struct({
-  revision: NonNegativeIntegerSchema,
-  interval: PositiveFiniteSchema,
-  billingInterval: PositiveFiniteSchema,
-  clearScreen: Schema.Boolean,
-  privacyMode: Schema.Boolean,
-  privacyToggleKey: Schema.String,
-  timezone: Schema.NullOr(Schema.String),
-  accounts: Schema.Array(AccountSchema),
-  activeAccountId: Schema.NullOr(Schema.String),
-  disabledProviders: Schema.Array(ProviderIdSchema),
-  onboarded: Schema.Boolean,
-  dashboardLayout: Schema.Literals(["grid", "single"]),
-  defaultFocus: Schema.Literals(["all", "last"]),
-  ascii: Schema.Literals(["auto", "on", "off"]),
-  allowNetworkAccess: Schema.Boolean,
-  allowedHosts: Schema.Array(Schema.String),
-  resetDisplay: Schema.Literals(["relative", "absolute"]),
-  knownProviders: Schema.Array(ProviderIdSchema)
-});
-var ProtocolInfoSchema = Schema.Struct({
-  version: Schema.Literal(TOKMON_PROTOCOL_VERSION),
-  // Capabilities are additive within a protocol version. Older clients must
-  // preserve forward compatibility when a newer daemon advertises one they do
-  // not understand yet.
-  capabilities: Schema.Array(Schema.String)
-});
-var ConfigStateSchema = Schema.Struct({
-  protocol: ProtocolInfoSchema,
-  config: ConfigSchema
-});
-var ConfigUpdateRequestSchema = Schema.Struct({
-  expectedRevision: NonNegativeIntegerSchema,
-  config: ConfigSchema
-});
-var ConfigUpdateConflictSchema = Schema.Struct({
-  kind: Schema.Literal("conflict"),
-  state: ConfigStateSchema
-});
-var ConfigPersistenceFailureSchema = Schema.Struct({
-  kind: Schema.Literal("persistence"),
-  message: Schema.String
-});
-var FsEntrySchema = Schema.Struct({
-  name: Schema.String,
-  path: Schema.String,
-  dir: Schema.Boolean
-});
-var FsListingSchema = Schema.Struct({
-  path: Schema.String,
-  parent: Schema.NullOr(Schema.String),
-  entries: Schema.Array(FsEntrySchema)
-});
-var UsageSummarySchema = Schema.Struct({
-  cost: Schema.Finite,
-  tokens: Schema.Finite,
-  input: Schema.Finite,
-  cacheRead: Schema.Finite,
-  cacheSavings: Schema.Finite
-});
-var ModelDetailSchema = Schema.Struct({
-  name: Schema.String,
-  input: Schema.Finite,
-  output: Schema.Finite,
-  cacheCreate: Schema.Finite,
-  cacheRead: Schema.Finite,
-  cacheSavings: Schema.Finite,
-  cost: Schema.Finite,
-  count: Schema.Finite
-});
-var TableRowSchema = Schema.Struct({
-  label: Schema.String,
-  models: Schema.Array(Schema.String),
-  input: Schema.Finite,
-  output: Schema.Finite,
-  cacheCreate: Schema.Finite,
-  cacheRead: Schema.Finite,
-  cacheSavings: Schema.Finite,
-  total: Schema.Finite,
-  cost: Schema.Finite,
-  count: Schema.Finite,
-  breakdown: Schema.Array(ModelDetailSchema)
-});
-var DashboardDataSchema = Schema.Struct({
-  today: UsageSummarySchema,
-  week: UsageSummarySchema,
-  month: UsageSummarySchema,
-  burnRate: Schema.Finite,
-  series: Schema.Array(Schema.Finite)
-});
-var TableDataSchema = Schema.Struct({
-  daily: Schema.Array(TableRowSchema),
-  weekly: Schema.Array(TableRowSchema),
-  monthly: Schema.Array(TableRowSchema)
-});
-var MetricFormatSchema = Schema.Union([
-  Schema.Struct({ kind: Schema.Literal("percent") }),
-  Schema.Struct({ kind: Schema.Literal("dollars"), currency: Schema.optionalKey(Schema.String) }),
-  Schema.Struct({ kind: Schema.Literal("count"), suffix: Schema.optionalKey(Schema.String) })
-]);
-var MetricSchema = Schema.Struct({
-  label: Schema.String,
-  used: Schema.Finite,
-  limit: Schema.NullOr(Schema.Finite),
-  format: MetricFormatSchema,
-  resetsAt: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  primary: Schema.optionalKey(Schema.Boolean)
-});
-var BillingResultSchema = Schema.Struct({
-  plan: Schema.NullOr(Schema.String),
-  metrics: Schema.Array(MetricSchema),
-  error: Schema.NullOr(Schema.String),
-  email: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  displayName: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  activity: Schema.optionalKey(Schema.NullOr(Schema.Struct({
-    series: Schema.Array(Schema.Finite),
-    summary: Schema.String
-  }))),
-  modelSpend: Schema.optionalKey(Schema.NullOr(Schema.Array(Schema.Struct({
-    name: Schema.String,
-    usd: Schema.Finite,
-    requests: Schema.Finite
-  })))),
-  asOfMs: Schema.optionalKey(Schema.Finite)
-});
-var WebAccountSchema = Schema.Struct({
-  id: Schema.String,
-  providerId: ProviderIdSchema,
-  name: Schema.String,
-  color: Schema.String,
-  homeDir: Schema.NullOr(Schema.String),
-  hasUsage: Schema.Boolean,
-  hasBilling: Schema.Boolean,
-  email: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  displayName: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  plan: Schema.optionalKey(Schema.NullOr(Schema.String)),
-  dashboard: Schema.NullOr(DashboardDataSchema),
-  table: Schema.NullOr(TableDataSchema),
-  billing: Schema.NullOr(BillingResultSchema),
-  summaryState: Schema.Literals(["pending", "ready", "error"]),
-  billingState: Schema.Literals(["pending", "ready", "error"]),
-  tableState: Schema.Literals(["pending", "ready", "error"]),
-  summaryUpdatedAt: Schema.optionalKey(Schema.NullOr(NonNegativeIntegerSchema)),
-  billingUpdatedAt: Schema.optionalKey(Schema.NullOr(NonNegativeIntegerSchema)),
-  tableUpdatedAt: Schema.optionalKey(Schema.NullOr(NonNegativeIntegerSchema))
-});
-var WebSnapshotSchema = Schema.Struct({
-  version: Schema.String,
-  generatedAt: NonNegativeIntegerSchema,
-  tz: Schema.String,
-  intervalMs: PositiveFiniteSchema,
-  billingIntervalMs: Schema.optionalKey(PositiveFiniteSchema),
-  providers: Schema.Array(Schema.Struct({
-    id: ProviderIdSchema,
-    name: Schema.String,
-    color: Schema.String
-  })),
-  accounts: Schema.Array(WebAccountSchema),
-  seeded: Schema.Boolean,
-  peak: Schema.NullOr(Schema.Struct({
-    state: Schema.Literals(["peak", "off-peak", "weekend"]),
-    label: Schema.String,
-    // The upstream clock is only normalized to a finite number; do not make
-    // the wire contract narrower than the producer's declared type.
-    minutesUntilChange: Schema.NullOr(Schema.Finite),
-    changesAt: Schema.optionalKey(Schema.NullOr(Schema.String))
-  }))
-});
-var EmptyPayloadSchema = Schema.Struct({});
-var GetConfigRpc = Rpc.make(TOKMON_WS_METHODS.getConfig, {
-  payload: EmptyPayloadSchema,
-  success: ConfigStateSchema
-});
-var SetConfigRpc = Rpc.make(TOKMON_WS_METHODS.setConfig, {
-  payload: ConfigUpdateRequestSchema,
-  success: ConfigStateSchema,
-  error: Schema.Union([ConfigUpdateConflictSchema, ConfigPersistenceFailureSchema])
-});
-var RefreshRpc = Rpc.make(TOKMON_WS_METHODS.refresh, {
-  payload: Schema.Struct({ scope: RefreshScopeSchema }),
-  success: Schema.Void
-});
-var BrowseFsRpc = Rpc.make(TOKMON_WS_METHODS.browseFs, {
-  payload: Schema.Struct({ path: Schema.String }),
-  success: FsListingSchema
-});
-var SnapshotRpc = Rpc.make(TOKMON_WS_METHODS.snapshot, {
-  payload: EmptyPayloadSchema,
-  success: WebSnapshotSchema,
-  stream: true
-});
-var ConfigRpc = Rpc.make(TOKMON_WS_METHODS.config, {
-  payload: EmptyPayloadSchema,
-  success: ConfigStateSchema,
-  stream: true
-});
-var TokmonRpcGroup = RpcGroup.make(
-  GetConfigRpc,
-  SetConfigRpc,
-  RefreshRpc,
-  BrowseFsRpc,
-  SnapshotRpc,
-  ConfigRpc
-);
-
 // src/shared/format.ts
 var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 function formatCurrency(value, opts = {}) {
@@ -984,7 +747,10 @@ function formatCurrency(value, opts = {}) {
   const abs = Math.abs(value);
   if (abs >= 1e5) return `${sign}$${(value / 1e3).toFixed(0)}k`;
   if (abs >= 1e4) return `${sign}$${(value / 1e3).toFixed(1)}k`;
-  if (abs >= 1) return `${sign}$${value.toFixed(2)}`;
+  if (abs >= 1) {
+    const polarity = value < 0 ? "-" : "";
+    return `${sign}${polarity}$${abs.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+  }
   if (abs >= 0.01) return `${sign}$${value.toFixed(3)}`;
   if (abs === 0) return "$0.00";
   return `${sign}$${value.toFixed(4)}`;
@@ -1021,17 +787,22 @@ function formatShortDate(label, opts = {}) {
   const day = Number(match[3]);
   return `${MONTHS[Number(match[2]) - 1]} ${opts.padDay ? day.toString().padStart(2, " ") : day}`;
 }
+function resetParts(diffMs) {
+  if (!Number.isFinite(diffMs) || diffMs <= 0) return null;
+  const totalMinutes = Math.max(1, Math.ceil(diffMs / 6e4));
+  return {
+    days: Math.floor(totalMinutes / (24 * 60)),
+    hours: Math.floor(totalMinutes % (24 * 60) / 60),
+    minutes: totalMinutes % 60,
+    totalMinutes
+  };
+}
 function formatResetIn(iso, now = Date.now()) {
-  const diff = new Date(iso).getTime() - now;
-  if (!Number.isFinite(diff) || diff <= 0) return "now";
-  const minutes = Math.round(diff / 6e4);
-  if (minutes < 60) return `${minutes}m`;
-  const hours = Math.floor(minutes / 60);
-  const mins = minutes % 60;
-  if (hours < 24) return `${hours}h ${mins}m`;
-  const days = Math.floor(hours / 24);
-  const hrs = hours % 24;
-  return `${days}d ${hrs}h`;
+  const parts = resetParts(new Date(iso).getTime() - now);
+  if (!parts) return "now";
+  if (parts.days > 0) return `${parts.days}d ${parts.hours}h`;
+  if (parts.hours > 0) return `${parts.hours}h ${parts.minutes}m`;
+  return `${parts.minutes}m`;
 }
 function formatResetAt(iso, display, now = Date.now(), tz) {
   const timestamp = Date.parse(iso);
@@ -1506,7 +1277,19 @@ function limitMetric(entry, primary) {
   if (used === void 0) return null;
   const label = limitLabel(o);
   if (!label) return null;
-  return percentMetric(label, used, resetFrom(o.resets_at), primary);
+  const scope = recordValue(o.scope);
+  const model = recordValue(scope?.model);
+  const modelId = nonEmptyString(model?.id);
+  const kind = nonEmptyString(o.kind)?.toLowerCase() ?? "";
+  const scopedModel = kind === "weekly_scoped" || kind.startsWith("weekly_model");
+  const role = kind === "session" || nonEmptyString(o.group)?.toLowerCase() === "session" ? "session" : kind === "weekly_all" ? "weekly" : modelId || scopedModel ? "model" : "other";
+  return {
+    ...percentMetric(label, used, resetFrom(o.resets_at), primary),
+    key: modelId ? `model:${modelId}` : kind || label.toLowerCase(),
+    role,
+    modelId: modelId ?? (scopedModel ? label.toLowerCase().replace(/\s+/g, "-") : null),
+    active: boolValue(o.is_active)
+  };
 }
 function limitMetrics(limits) {
   if (!Array.isArray(limits)) return [];
@@ -1533,7 +1316,12 @@ function topLevelUsageMetrics(data) {
     const window = recordValue(value);
     if (!window || numberValue(window.utilization) === void 0) continue;
     const metric = usageMetric(usageLabelFromKey(key), window, key === "five_hour" ? true : void 0);
-    if (metric) metrics.push(metric);
+    if (metric) metrics.push({
+      ...metric,
+      key,
+      role: key === "five_hour" ? "session" : key === "seven_day" ? "weekly" : key.startsWith("seven_day_") ? "model" : "other",
+      modelId: key.startsWith("seven_day_") ? key.slice("seven_day_".length) : null
+    });
   }
   return metrics;
 }
@@ -1576,6 +1364,8 @@ async function claudeBilling(account) {
       if (usedCredits !== void 0 && (usedCredits > 0 || monthlyLimit !== void 0 && monthlyLimit > 0)) {
         const scale = decimalScale(data.extra_usage?.decimal_places);
         metrics.push({
+          key: "extra_usage",
+          role: "unbounded",
           label: "Extra",
           used: finite(usedCredits) / scale,
           limit: monthlyLimit !== void 0 && monthlyLimit > 0 ? monthlyLimit / scale : null,
@@ -1727,13 +1517,14 @@ function timestampSecond(value) {
   const ts = timestampMs(value);
   return ts === null ? null : new Date(ts).toISOString().slice(0, 19);
 }
-async function hasThreadSpawn(path) {
+async function hasForkedHistory(path) {
   let handle = null;
   try {
     handle = await openFile(path, "r");
     const buffer = Buffer.alloc(16 * 1024);
     const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
-    return buffer.subarray(0, bytesRead).includes("thread_spawn");
+    const prefix = buffer.subarray(0, bytesRead).toString("utf8");
+    return prefix.includes("thread_spawn") && /"forked_from_id"\s*:\s*"[^"]+"/.test(prefix);
   } catch {
     return false;
   } finally {
@@ -1741,32 +1532,11 @@ async function hasThreadSpawn(path) {
     });
   }
 }
-async function detectReplaySecond(path) {
-  if (!await hasThreadSpawn(path)) return null;
-  let first = null;
-  const input = createReadStream2(path);
-  input.on("error", () => {
-  });
-  const rl = createInterface2({ input, crlfDelay: Infinity });
-  try {
-    for await (const rawLine of rl) {
-      if (!rawLine.includes("token_count")) continue;
-      try {
-        const line = rawLine.charCodeAt(0) === 65279 ? rawLine.slice(1) : rawLine;
-        const obj = JSON.parse(line);
-        if ((obj?.payload?.type ?? obj?.type) !== "token_count") continue;
-        const info = obj?.payload?.info;
-        if (!normalizeUsage(info?.last_token_usage) && !normalizeUsage(info?.total_token_usage)) continue;
-        const second = timestampSecond(obj.timestamp ?? obj?.payload?.timestamp);
-        if (!second) continue;
-        if (!first) first = second;
-        else return first === second ? second : null;
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return null;
+function isLiveTaskStart(obj) {
+  if ((obj?.payload?.type ?? obj?.type) !== "task_started") return false;
+  const eventSecond = timestampSecond(obj?.timestamp ?? obj?.payload?.timestamp);
+  const startedSecond = timestampSecond(obj?.payload?.started_at);
+  return eventSecond !== null && eventSecond === startedSecond;
 }
 function findUsage(obj) {
   return normalizeUsage(obj?.usage) ?? normalizeUsage(obj?.payload?.usage) ?? normalizeUsage(obj?.payload?.info?.usage) ?? normalizeUsage(obj?.result?.usage) ?? normalizeUsage(obj?.response?.usage) ?? normalizeUsage(obj?.token_usage) ?? normalizeUsage(obj);
@@ -1779,19 +1549,22 @@ async function parseFile2(path) {
   let model = "gpt-5";
   let prevTotal = null;
   let prevSig = null;
-  const replaySecond = await detectReplaySecond(path);
-  let skipReplay = replaySecond !== null;
+  let skipReplay = await hasForkedHistory(path);
   const input = createReadStream2(path);
   input.on("error", () => {
   });
   const rl = createInterface2({ input, crlfDelay: Infinity });
   try {
     for await (const rawLine of rl) {
-      if (!rawLine.includes("token_count") && !rawLine.includes("turn_context") && !rawLine.includes('"usage"') && !rawLine.includes("input_tokens") && !rawLine.includes("prompt_tokens")) continue;
+      if (!rawLine.includes("token_count") && !rawLine.includes("task_started") && !rawLine.includes("turn_context") && !rawLine.includes('"usage"') && !rawLine.includes("input_tokens") && !rawLine.includes("prompt_tokens")) continue;
       try {
         const line = rawLine.charCodeAt(0) === 65279 ? rawLine.slice(1) : rawLine;
         const obj = JSON.parse(line);
         const payloadType = obj?.payload?.type ?? obj?.type;
+        if (skipReplay) {
+          if (isLiveTaskStart(obj)) skipReplay = false;
+          continue;
+        }
         if (payloadType === "turn_context") {
           const m2 = extractModel(obj);
           if (typeof m2 === "string" && m2.trim()) model = m2;
@@ -1827,14 +1600,6 @@ async function parseFile2(path) {
         const total = normalizeUsage(info?.total_token_usage);
         const last = normalizeUsage(info?.last_token_usage);
         const tsValue = obj.timestamp ?? obj?.payload?.timestamp;
-        if (skipReplay && replaySecond) {
-          const second = timestampSecond(tsValue);
-          if (second === replaySecond) {
-            if (total) prevTotal = total;
-            continue;
-          }
-          if (second) skipReplay = false;
-        }
         const sig = eventSig(last, total);
         if (sig === prevSig) continue;
         prevSig = sig;
@@ -4622,11 +4387,6 @@ async function detectProviders() {
 }
 
 export {
-  TOKMON_WS_PATH,
-  TOKMON_PROTOCOL_VERSION,
-  TOKMON_CAPABILITIES,
-  TOKMON_WS_METHODS,
-  TokmonRpcGroup,
   withTimeout,
   systemTimezone,
   resolveTimezone,