tokmon 0.23.5 → 0.24.0

package/README.md

@@ -26,6 +26,22 @@ npm install -g tokmon
 
 Then run `tokmon`. On first launch you'll pick which providers to track; press `q` to quit any time.
 
+## CLI Data Queries
+
+Scripts and coding agents can query the same daemon directly without opening the interactive dashboard:
+
+```bash
+tokmon usage                              # current-month usage by provider/account/model
+tokmon usage --period week --provider codex
+tokmon usage --model opus --json          # stable machine-readable schema
+tokmon usage --period all --json --compact
+tokmon providers --json                   # accounts plus local config/auth/usage paths
+tokmon snapshot --refresh                 # complete raw daemon snapshot
+tokmon config path                        # tokmon config file location
+```
+
+`usage` refreshes local history by default; use `--cached` for the fastest cached answer or `--refresh` to refresh billing as well. JSON reports include `schemaVersion`, exact provider/account source IDs, per-model token and cost fields, and a `sources` collection that maps every model row to its provider home and discovered local paths. Run `tokmon usage --help` or `tokmon providers --help` for every filter and example.
+
 ## Providers
 
 **Usage providers** — full cost & token history (Today / Week / Month, sparkline, per-model table):
@@ -186,6 +202,10 @@ Press `s` to open.
 ```
 tokmon [options]            Launch the terminal dashboard
 tokmon serve [options]      Launch the web dashboard (http://127.0.0.1:4317)
+tokmon usage [options]      Query usage by model (human or JSON)
+tokmon providers [options]  Show accounts and local provider paths
+tokmon snapshot [options]   Print the raw daemon snapshot as JSON
+tokmon config [path]        Print the tokmon config file location
 
 Options:
 -i, --interval <seconds>  Refresh interval in seconds (default: from config, or 2)

package/dist/{bootstrap-ink-WA3ENW2M.js → bootstrap-ink-HL2BYNW3.js}

@@ -1,28 +1,27 @@
 #!/usr/bin/env node
 import {
-  PROVIDERS,
-  PROVIDER_ORDER,
-  TOKMON_WS_METHODS,
-  TOKMON_WS_PATH,
-  TokmonRpcGroup,
+  createDaemonRpcClient
+} from "./chunk-45ZP755H.js";
+import {
   accountsByProvider,
   buildAccounts,
+  fetchPeak,
+  modelColor
+} from "./chunk-42H7R376.js";
+import {
+  PROVIDERS,
+  PROVIDER_ORDER,
   coalesceTables,
   col,
   currency,
   detectProviders,
-  fetchPeak,
-  modelColor,
   resolveTimezone,
   shortDate,
   systemTimezone,
   time,
   tokens,
   withTimeout
-} from "./chunk-IELQ5EY3.js";
-import {
-  glyphs
-} from "./chunk-RF4GGQGM.js";
+} from "./chunk-O27I2XFN.js";
 import {
   COLOR_PALETTE,
   DEFAULTS,
@@ -38,6 +37,9 @@ import {
   saveConfigSync,
   snapshotCacheFile
 } from "./chunk-5CWOJMAH.js";
+import {
+  glyphs
+} from "./chunk-RF4GGQGM.js";
 
 // src/bootstrap-ink.tsx
 import { render } from "ink";
@@ -1607,273 +1609,6 @@ function TinyRow({ provider, accounts, stats, width }) {
 
 // src/client/use-daemon.ts
 import { useEffect as useEffect3, useMemo, useRef as useRef2, useState as useState3 } from "react";
-
-// src/client/daemon-rpc-client.ts
-import { Cause, Context, Duration, Effect, Exit, Fiber, Layer, ManagedRuntime, Schedule, Stream } from "effect";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import * as Socket from "effect/unstable/socket/Socket";
-var TokmonRpcClient = class extends Context.Service()(
-  "tokmon/client/DaemonRpcClient/TokmonRpcClient"
-) {
-};
-var dynamicImport = new Function("specifier", "return import(specifier)");
-function toWsUrl(baseUrl) {
-  const base = typeof window === "undefined" ? void 0 : window.location.origin;
-  const url = new URL(baseUrl, base);
-  if (url.protocol === "http:") url.protocol = "ws:";
-  else if (url.protocol === "https:") url.protocol = "wss:";
-  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
-    throw new Error(`unsupported daemon RPC protocol: ${url.protocol}`);
-  }
-  url.hash = "";
-  url.searchParams.delete("tokmonToken");
-  url.searchParams.delete("wsToken");
-  url.pathname = TOKMON_WS_PATH;
-  return url.toString();
-}
-function shouldUseNodeTransport(transport) {
-  if (transport === "node") return true;
-  if (transport === "browser") return false;
-  return typeof window === "undefined";
-}
-async function socketLayerFor(url, transport) {
-  if (shouldUseNodeTransport(transport)) {
-    const NodeSocket = await dynamicImport("@effect/platform-node/NodeSocket");
-    return NodeSocket.layerWebSocket(url);
-  }
-  return Socket.layerWebSocket(url).pipe(
-    Layer.provide(Socket.layerWebSocketConstructorGlobal)
-  );
-}
-function retryPolicy(options) {
-  const baseDelay = options.reconnectBaseDelayMs ?? 250;
-  const policy = Schedule.exponential(Duration.millis(baseDelay), 1.5).pipe(
-    Schedule.either(Schedule.spaced(Duration.millis(2500)))
-  );
-  return typeof options.reconnectAttempts === "number" ? policy.pipe(Schedule.both(Schedule.recurs(options.reconnectAttempts))) : policy;
-}
-function createDaemonRpcClient(baseUrl, options = {}) {
-  const url = toWsUrl(baseUrl);
-  const fibers = /* @__PURE__ */ new Set();
-  let session = null;
-  let sessionPromise = null;
-  let closed = false;
-  const setConn = (state, error) => {
-    options.onConn?.(state, error);
-  };
-  const resetSession = (active) => {
-    if (active !== void 0 && active !== null && active !== session) {
-      void active.runtime.dispose().catch(() => {
-      });
-      return;
-    }
-    const dead = active ?? session;
-    session = null;
-    sessionPromise = null;
-    if (dead) void dead.runtime.dispose().catch(() => {
-    });
-  };
-  const makeProtocolLayer = async () => {
-    const socketLayer = await socketLayerFor(url, options.transport);
-    const connectionHooksLayer = Layer.succeed(
-      RpcClient.ConnectionHooks,
-      RpcClient.ConnectionHooks.of({
-        onConnect: Effect.sync(() => {
-          setConn("live");
-        }),
-        onDisconnect: Effect.sync(() => {
-          if (!closed) {
-            setConn("reconnecting");
-          }
-        })
-      })
-    );
-    return Layer.effect(
-      RpcClient.Protocol,
-      RpcClient.makeProtocolSocket({
-        retryPolicy: retryPolicy(options),
-        retryTransientErrors: true
-      })
-    ).pipe(
-      Layer.provide(Layer.mergeAll(socketLayer, RpcSerialization.layerJson, connectionHooksLayer))
-    );
-  };
-  const ensureSession = async () => {
-    if (closed) throw new Error("daemon RPC client is closed");
-    if (session) return session;
-    if (sessionPromise) return sessionPromise;
-    setConn("connecting");
-    sessionPromise = (async () => {
-      let runtime;
-      try {
-        const protocolLayer = await makeProtocolLayer();
-        const clientLayer = Layer.effect(
-          TokmonRpcClient,
-          RpcClient.make(TokmonRpcGroup)
-        ).pipe(
-          Layer.provide(protocolLayer)
-        );
-        runtime = ManagedRuntime.make(clientLayer);
-        await runtime.runPromise(TokmonRpcClient.asEffect());
-        if (closed) {
-          await runtime.dispose();
-          throw new Error("daemon RPC client is closed");
-        }
-        session = { runtime };
-        return session;
-      } catch (error) {
-        sessionPromise = null;
-        await runtime?.dispose().catch(() => {
-        });
-        if (!closed) setConn("error", error);
-        throw error;
-      }
-    })();
-    return sessionPromise;
-  };
-  const run = async (effectFor) => {
-    const active = await ensureSession();
-    try {
-      return await active.runtime.runPromise(
-        TokmonRpcClient.use((client) => effectFor(client))
-      );
-    } catch (error) {
-      if (!closed) {
-        resetSession(active);
-        setConn("error", error);
-      }
-      throw error;
-    }
-  };
-  const subscribe = (streamFor, onValue, staleAfterFor) => {
-    if (closed) return () => {
-    };
-    let fiber = null;
-    let unsubscribed = false;
-    let retryTimer = null;
-    let watchdogTimer = null;
-    let lastValueAt = 0;
-    let staleAfterMs = Number.POSITIVE_INFINITY;
-    let watchdogRestart = false;
-    const stopFiber = () => {
-      if (!fiber) return;
-      const current = fiber;
-      fiber = null;
-      fibers.delete(current);
-      void (session?.runtime.runPromise(Fiber.interrupt(current)) ?? Effect.runPromise(Fiber.interrupt(current))).catch(() => {
-      });
-    };
-    const scheduleRetry = () => {
-      if (closed || unsubscribed || retryTimer) return;
-      retryTimer = setTimeout(() => {
-        retryTimer = null;
-        start();
-      }, options.reconnectBaseDelayMs ?? 250);
-      retryTimer.unref?.();
-    };
-    if (staleAfterFor) {
-      const checkEveryMs = Math.min(5e3, Math.max(10, (options.snapshotStaleFloorMs ?? 9e4) / 2));
-      watchdogTimer = setInterval(() => {
-        if (!fiber || lastValueAt === 0 || Date.now() - lastValueAt <= staleAfterMs) return;
-        watchdogRestart = true;
-        lastValueAt = Date.now();
-        setConn("reconnecting");
-        stopFiber();
-      }, checkEveryMs);
-      watchdogTimer.unref?.();
-    }
-    const start = () => {
-      void (async () => {
-        try {
-          const active = await ensureSession();
-          if (closed || unsubscribed) return;
-          lastValueAt = Date.now();
-          staleAfterMs = options.snapshotStaleFloorMs ?? 9e4;
-          const currentFiber = active.runtime.runFork(
-            TokmonRpcClient.use(
-              (client) => streamFor(client).pipe(
-                Stream.runForEach(
-                  (value) => Effect.sync(() => {
-                    lastValueAt = Date.now();
-                    if (staleAfterFor) staleAfterMs = staleAfterFor(value);
-                    try {
-                      onValue(value);
-                    } catch {
-                    }
-                  })
-                )
-              )
-            )
-          );
-          fiber = currentFiber;
-          fibers.add(currentFiber);
-          currentFiber.addObserver((exit) => {
-            fibers.delete(currentFiber);
-            if (fiber === currentFiber) fiber = null;
-            if (closed || unsubscribed) return;
-            const stale = watchdogRestart;
-            watchdogRestart = false;
-            resetSession(active);
-            if (stale || Exit.isSuccess(exit)) setConn("reconnecting");
-            else setConn("error", Cause.squash(exit.cause));
-            scheduleRetry();
-          });
-        } catch (error) {
-          if (!closed && !unsubscribed) {
-            resetSession();
-            setConn("error", error);
-            scheduleRetry();
-          }
-        }
-      })();
-    };
-    start();
-    return () => {
-      unsubscribed = true;
-      if (retryTimer) {
-        clearTimeout(retryTimer);
-        retryTimer = null;
-      }
-      if (watchdogTimer) {
-        clearInterval(watchdogTimer);
-        watchdogTimer = null;
-      }
-      stopFiber();
-    };
-  };
-  return {
-    getConfig: () => run((client) => client[TOKMON_WS_METHODS.getConfig]({})).then((state) => state),
-    setConfig: (config) => run((client) => client[TOKMON_WS_METHODS.setConfig](config)).then((state) => state),
-    refresh: (scope = "all") => run((client) => client[TOKMON_WS_METHODS.refresh]({ scope })),
-    browseFs: (path) => run((client) => client[TOKMON_WS_METHODS.browseFs]({ path })),
-    subscribeSnapshot: (onSnapshot) => subscribe(
-      (client) => client[TOKMON_WS_METHODS.snapshot]({}).pipe(Stream.map((value) => value)),
-      onSnapshot,
-      (snapshot) => Math.max(options.snapshotStaleFloorMs ?? 9e4, snapshot.intervalMs * 3)
-    ),
-    subscribeConfig: (onConfig) => subscribe((client) => client[TOKMON_WS_METHODS.config]({}).pipe(Stream.map((value) => value)), onConfig),
-    async close() {
-      if (closed) return;
-      closed = true;
-      setConn("closed");
-      const active = [...fibers];
-      fibers.clear();
-      const activeSession = session ?? await sessionPromise?.catch(() => null) ?? null;
-      await Promise.all(active.map(
-        (fiber) => (activeSession?.runtime.runPromise(Fiber.interrupt(fiber)) ?? Effect.runPromise(Fiber.interrupt(fiber))).catch(() => {
-        })
-      ));
-      session = null;
-      sessionPromise = null;
-      if (activeSession) {
-        await activeSession.runtime.dispose().catch(() => {
-        });
-      }
-    }
-  };
-}
-
-// src/client/use-daemon.ts
 function useDaemon(baseUrl) {
   const [snapshot, setSnapshot] = useState3(null);
   const [conn, setConn] = useState3("connecting");
@@ -3654,7 +3389,7 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, mode = "deg
     if (webStartingRef.current) return;
     webStartingRef.current = true;
     try {
-      const { startWebServer } = await import("./server-XUCQWX6N.js");
+      const { startWebServer } = await import("./server-X63FGHIZ.js");
       const ctrl = await startWebServer({ config: cfg, log: false });
       webRef.current = ctrl;
       openUrl(ctrl.url);

package/dist/chunk-42H7R376.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+import {
+  PROVIDERS,
+  PROVIDER_ORDER,
+  identityFromIdToken,
+  readClaudeIdentity,
+  readJson
+} from "./chunk-O27I2XFN.js";
+import {
+  expandHome,
+  slugify
+} from "./chunk-5CWOJMAH.js";
+
+// src/accounts.ts
+import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { homedir } from "os";
+import { basename, join as join2, resolve } from "path";
+
+// src/providers/codex/identity.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+function codexAuthPaths(homeDir) {
+  return [join(homeDir, ".codex", "auth.json"), join(homeDir, "auth.json")];
+}
+function readCodexIdentity(homeDir) {
+  for (const path of codexAuthPaths(homeDir)) {
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8"));
+      const { email, displayName, payload } = identityFromIdToken(parsed?.tokens?.id_token);
+      if (!payload) continue;
+      return { email, displayName };
+    } catch {
+    }
+  }
+  return {};
+}
+
+// src/accounts.ts
+function accountKey(providerId, homeDir) {
+  return `${providerId}:${homeDir ? resolve(expandHome(homeDir)) : homedir()}`;
+}
+function uniqueId(base, used) {
+  let id = slugify(base) || "account";
+  if (!used.has(id)) {
+    used.add(id);
+    return id;
+  }
+  for (let i = 2; i < 1e3; i++) {
+    const next = `${id}_${i}`;
+    if (!used.has(next)) {
+      used.add(next);
+      return next;
+    }
+  }
+  id = `${id}_${Date.now()}`;
+  used.add(id);
+  return id;
+}
+function hasClaudeState(homeDir) {
+  return existsSync(join2(homeDir, ".claude.json")) || existsSync(join2(homeDir, ".claude", ".credentials.json")) || existsSync(join2(homeDir, ".claude", "projects")) || existsSync(join2(homeDir, ".config", "claude", ".credentials.json")) || existsSync(join2(homeDir, ".config", "claude", "projects"));
+}
+function candidateAlternateHomes(prefix) {
+  const home = homedir();
+  let entries;
+  try {
+    entries = readdirSync(home);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const pattern = new RegExp(`^\\.${prefix}[_-]`);
+  for (const name of entries) {
+    if (!pattern.test(name)) continue;
+    const path = join2(home, name);
+    try {
+      if (!statSync(path).isDirectory()) continue;
+      out.push(path);
+    } catch {
+    }
+  }
+  return out.sort();
+}
+function labelForClaudeHome(homeDir) {
+  const identity = readClaudeIdentity(homeDir);
+  if (identity.email) return `Claude ${identity.email}`;
+  if (identity.displayName) return `Claude ${identity.displayName}`;
+  const raw = basename(homeDir).replace(/^\.claude[_-]?/, "").replace(/[_-]+/g, " ").trim();
+  return raw ? `Claude ${raw}` : "Claude";
+}
+function hasCodexAuth(homeDir) {
+  for (const path of codexAuthPaths(homeDir)) {
+    try {
+      const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+      const accessToken = parsed?.tokens?.access_token;
+      if (typeof accessToken === "string" && accessToken.trim()) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function labelForCodexHome(homeDir) {
+  const identity = readCodexIdentity(homeDir);
+  if (identity.email) return `Codex ${identity.email}`;
+  if (identity.displayName) return `Codex ${identity.displayName}`;
+  const raw = basename(homeDir).replace(/^\.codex[_-]?/, "").replace(/[_-]+/g, " ").trim();
+  return raw ? `Codex ${raw}` : "Codex";
+}
+function discoverClaudeAccounts(usedIds) {
+  const provider = PROVIDERS.claude;
+  const out = [];
+  for (const homeDir of candidateAlternateHomes("claude")) {
+    if (!hasClaudeState(homeDir)) continue;
+    const suffix = basename(homeDir).replace(/^\.claude[_-]?/, "") || basename(homeDir);
+    out.push({
+      id: uniqueId(`claude_${suffix}`, usedIds),
+      providerId: "claude",
+      name: labelForClaudeHome(homeDir),
+      color: provider.color,
+      homeDir
+    });
+  }
+  return out;
+}
+function discoverCodexAccounts(usedIds) {
+  const provider = PROVIDERS.codex;
+  const out = [];
+  for (const homeDir of candidateAlternateHomes("codex")) {
+    if (!hasCodexAuth(homeDir)) continue;
+    const suffix = basename(homeDir).replace(/^\.codex[_-]?/, "") || basename(homeDir);
+    out.push({
+      id: uniqueId(`codex_${suffix}`, usedIds),
+      providerId: "codex",
+      name: labelForCodexHome(homeDir),
+      color: provider.color,
+      homeDir
+    });
+  }
+  return out;
+}
+function discoverProviderAccounts(providerId, usedIds) {
+  if (providerId === "claude") return discoverClaudeAccounts(usedIds);
+  if (providerId === "codex") return discoverCodexAccounts(usedIds);
+  return [];
+}
+function buildAccounts(config, detected) {
+  const out = [];
+  const usedIds = new Set(config.accounts.map((a) => a.id));
+  const seenKeys = /* @__PURE__ */ new Set();
+  const add = (account) => {
+    const key = accountKey(account.providerId, account.homeDir);
+    if (seenKeys.has(key)) return;
+    seenKeys.add(key);
+    out.push(account);
+  };
+  for (const pid of PROVIDER_ORDER) {
+    if (config.disabledProviders.includes(pid)) continue;
+    const provider = PROVIDERS[pid];
+    const configured = config.accounts.filter((a) => a.providerId === pid);
+    for (const a of configured) {
+      add({
+        id: a.id,
+        providerId: pid,
+        name: a.name,
+        color: a.color || provider.color,
+        homeDir: a.homeDir && a.homeDir !== "~" ? expandHome(a.homeDir) : void 0
+      });
+    }
+    const discovered = discoverProviderAccounts(pid, usedIds);
+    if (detected.includes(pid)) {
+      add({ id: pid, providerId: pid, name: provider.name, color: provider.color, homeDir: void 0 });
+    }
+    for (const account of discovered) {
+      add(account);
+    }
+  }
+  return out;
+}
+function accountsByProvider(accounts) {
+  const groups = [];
+  for (const pid of PROVIDER_ORDER) {
+    const list = accounts.filter((a) => a.providerId === pid);
+    if (list.length > 0) groups.push({ provider: pid, accounts: list });
+  }
+  return groups;
+}
+
+// src/shared/colors.ts
+var FALLBACK_HEX = "#8d9090";
+var NAMED_HEX = {
+  green: "#6caa71",
+  greenBright: "#79be7e",
+  cyan: "#7ccbcd",
+  cyanBright: "#84dde0",
+  blue: "#6d96b4",
+  blueBright: "#67b5ed",
+  magenta: "#bd7bcd",
+  magentaBright: "#d389e5",
+  yellow: "#c4ac62",
+  yellowBright: "#d9c074",
+  red: "#b45648",
+  redBright: "#cf6a5a",
+  white: "#dee5eb",
+  whiteBright: "#f3f5f5",
+  gray: FALLBACK_HEX,
+  grey: FALLBACK_HEX
+};
+var PROVIDER_HEX = {
+  claude: NAMED_HEX.green,
+  codex: NAMED_HEX.cyan,
+  cursor: NAMED_HEX.magenta,
+  copilot: NAMED_HEX.white,
+  pi: NAMED_HEX.blue,
+  opencode: NAMED_HEX.yellow,
+  antigravity: NAMED_HEX.red,
+  gemini: NAMED_HEX.greenBright,
+  grok: NAMED_HEX.yellowBright
+};
+function namedHex(name) {
+  if (!name) return FALLBACK_HEX;
+  if (name.startsWith("#")) return name;
+  return NAMED_HEX[name] ?? FALLBACK_HEX;
+}
+function colorHex(accountColor, providerColorName) {
+  if (accountColor) {
+    if (accountColor.startsWith("#")) return accountColor;
+    const named = NAMED_HEX[accountColor];
+    if (named) return named;
+  }
+  return namedHex(providerColorName);
+}
+var MODEL_PALETTE = [
+  "#00d7ff",
+  "#00d787",
+  "#e6b450",
+  "#d75f87",
+  "#5f87ff",
+  "#af87ff",
+  "#5fd7a7",
+  "#ff8787",
+  "#d7af5f",
+  "#87d7ff",
+  "#d787d7",
+  "#9ee493",
+  "#ffb454",
+  "#7aa2f7",
+  "#bb9af7"
+];
+var modelColorCache = /* @__PURE__ */ new Map();
+function modelColor(name) {
+  const cached = modelColorCache.get(name);
+  if (cached) return cached;
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) hash = hash * 31 + name.charCodeAt(i) >>> 0;
+  const color = MODEL_PALETTE[hash % MODEL_PALETTE.length];
+  modelColorCache.set(name, color);
+  return color;
+}
+var TOKEN_BUCKET = {
+  input: NAMED_HEX.blue,
+  output: NAMED_HEX.green,
+  cacheCreate: NAMED_HEX.yellow,
+  cacheRead: NAMED_HEX.cyan
+};
+
+// src/peak.ts
+async function fetchPeak() {
+  try {
+    const res = await fetch("https://promoclock.co/api/status", {
+      headers: { "Accept": "application/json", "User-Agent": "tokmon" },
+      signal: AbortSignal.timeout(3e3)
+    });
+    if (!res.ok) return null;
+    const data = await readJson(res);
+    if (!data) return null;
+    let state;
+    if (data.isPeak === true || data.status === "peak") state = "peak";
+    else if (data.isWeekend === true || data.status === "weekend") state = "weekend";
+    else if (data.isOffPeak === true || data.status === "off_peak" || data.status === "off-peak") state = "off-peak";
+    else return null;
+    const minutesUntilChange = typeof data.minutesUntilChange === "number" && Number.isFinite(data.minutesUntilChange) ? data.minutesUntilChange : null;
+    return {
+      state,
+      label: state === "peak" ? "Peak" : state === "weekend" ? "Weekend" : "Off-Peak",
+      minutesUntilChange
+    };
+  } catch {
+    return null;
+  }
+}
+
+export {
+  buildAccounts,
+  accountsByProvider,
+  namedHex,
+  colorHex,
+  modelColor,
+  fetchPeak
+};