tokmon 0.23.5 → 0.24.0

package/dist/{chunk-MJWFCDBB.js → chunk-REO4O5VE.js}

@@ -6,6 +6,12 @@ import {
   sendJson,
   serveStatic
 } from "./chunk-SMPY52EV.js";
+import {
+  buildAccounts,
+  colorHex,
+  fetchPeak,
+  namedHex
+} from "./chunk-42H7R376.js";
 import {
   PROVIDERS,
   TOKMON_CAPABILITIES,
@@ -13,14 +19,10 @@ import {
   TOKMON_WS_METHODS,
   TOKMON_WS_PATH,
   TokmonRpcGroup,
-  buildAccounts,
-  colorHex,
   detectProviders,
-  fetchPeak,
-  namedHex,
   resolveTimezone,
   withTimeout
-} from "./chunk-IELQ5EY3.js";
+} from "./chunk-O27I2XFN.js";
 import {
   cacheDir,
   expandHome,

package/dist/{daemon-handle-Y2N2NA6D.js → chunk-W2WGBXZG.js}

@@ -9,7 +9,6 @@ import {
 import {
   appVersion
 } from "./chunk-SMPY52EV.js";
-import "./chunk-5CWOJMAH.js";
 
 // src/client/daemon-handle.ts
 import { spawn } from "child_process";
@@ -157,6 +156,7 @@ function degraded() {
   return { kind: "degraded", baseUrl: null, stop: () => {
   } };
 }
+
 export {
   attachOrSpawn
 };

package/dist/cli-command-TLGIGF63.js

@@ -0,0 +1,526 @@
+#!/usr/bin/env node
+import {
+  attachOrSpawn
+} from "./chunk-W2WGBXZG.js";
+import "./chunk-3TJVFKXV.js";
+import "./chunk-SMPY52EV.js";
+import {
+  createDaemonRpcClient
+} from "./chunk-45ZP755H.js";
+import {
+  PROVIDERS,
+  antigravityStateDb,
+  claudeConfigDirs,
+  codexHomes,
+  copilotStateDirs,
+  cursorStateDb,
+  dayKey,
+  geminiCredsPath,
+  geminiDir,
+  geminiTmpDir,
+  ghHostsPath,
+  grokAuthPaths,
+  grokHomes,
+  opencodeDbPaths,
+  piSessionsDir,
+  startOfMonth,
+  startOfWeek,
+  withTimeout
+} from "./chunk-O27I2XFN.js";
+import {
+  PROVIDER_IDS,
+  configLocation
+} from "./chunk-5CWOJMAH.js";
+
+// src/provider-locations.ts
+import { access } from "fs/promises";
+import { join } from "path";
+async function location(kind, path) {
+  let exists = false;
+  try {
+    await access(path);
+    exists = true;
+  } catch {
+  }
+  return { kind, path, exists };
+}
+function unique(items) {
+  const seen = /* @__PURE__ */ new Set();
+  return items.filter(([kind, path]) => {
+    const key = `${kind}:${path}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function providerLocations(providerId, homeDir) {
+  let candidates;
+  switch (providerId) {
+    case "claude":
+      candidates = claudeConfigDirs(homeDir).flatMap((dir) => [
+        ["config", dir],
+        ["auth", join(dir, ".credentials.json")],
+        ["usage", join(dir, "projects")]
+      ]);
+      break;
+    case "codex":
+      candidates = codexHomes(homeDir).flatMap((dir) => [
+        ["config", dir],
+        ["auth", join(dir, "auth.json")],
+        ["usage", join(dir, "sessions")],
+        ["usage", join(dir, "archived_sessions")]
+      ]);
+      break;
+    case "cursor": {
+      const state = cursorStateDb(homeDir);
+      candidates = [["state", state], ["usage", state]];
+      break;
+    }
+    case "copilot":
+      candidates = [
+        ["auth", ghHostsPath(homeDir)],
+        ...copilotStateDirs(homeDir).map((path) => ["state", path])
+      ];
+      break;
+    case "pi":
+      candidates = [["usage", piSessionsDir(homeDir)]];
+      break;
+    case "opencode":
+      candidates = opencodeDbPaths(homeDir).map((path) => ["usage", path]);
+      break;
+    case "antigravity":
+      candidates = [["state", await antigravityStateDb(homeDir)]];
+      break;
+    case "gemini":
+      candidates = [
+        ["config", geminiDir(homeDir)],
+        ["auth", geminiCredsPath(homeDir)],
+        ["usage", geminiTmpDir(homeDir)]
+      ];
+      break;
+    case "grok":
+      candidates = [
+        ...grokHomes(homeDir).map((path) => ["config", path]),
+        ...grokAuthPaths(homeDir).map((path) => ["auth", path]),
+        ...grokHomes(homeDir).map((path) => ["usage", join(path, "logs")])
+      ];
+      break;
+  }
+  return Promise.all(unique(candidates).map(([kind, path]) => location(kind, path)));
+}
+
+// src/cli-query.ts
+var CLI_SCHEMA_VERSION = 1;
+var USAGE_PERIODS = ["today", "week", "month", "all"];
+function sourceId(account) {
+  return `${account.providerId}:${account.id}`;
+}
+function firstDayFor(period, now, tz) {
+  if (period === "all") return null;
+  if (period === "today") return dayKey(now, tz);
+  if (period === "week") return dayKey(startOfWeek(now, tz), tz);
+  return dayKey(startOfMonth(now, tz), tz);
+}
+function accountMatches(account, filters) {
+  if (filters.provider && account.providerId !== filters.provider) return false;
+  if (!filters.account) return true;
+  const needle = filters.account.toLowerCase();
+  return account.id.toLowerCase() === needle || account.name.toLowerCase().includes(needle) || (account.email?.toLowerCase().includes(needle) ?? false);
+}
+async function cliSource(account) {
+  return {
+    id: sourceId(account),
+    providerId: account.providerId,
+    provider: PROVIDERS[account.providerId].name,
+    accountId: account.id,
+    account: account.email || account.displayName || account.name,
+    homeDir: account.homeDir,
+    locations: await providerLocations(account.providerId, account.homeDir ?? void 0)
+  };
+}
+function addUsage(target, value) {
+  target.input += value.input;
+  target.output += value.output;
+  target.cacheCreate += value.cacheCreate;
+  target.cacheRead += value.cacheRead;
+  target.tokens += value.tokens;
+  target.cacheSavings += value.cacheSavings;
+  target.cost += value.cost;
+  target.calls += value.calls;
+}
+var ZERO_TOTALS = () => ({
+  input: 0,
+  output: 0,
+  cacheCreate: 0,
+  cacheRead: 0,
+  tokens: 0,
+  cacheSavings: 0,
+  cost: 0,
+  calls: 0
+});
+async function buildUsageReport(snapshot, filters, now = Date.now(), tokmonConfig = configLocation()) {
+  const firstDay = firstDayFor(filters.period, now, snapshot.tz);
+  const accounts = snapshot.accounts.filter((account) => accountMatches(account, filters));
+  const sources = await Promise.all(accounts.map(cliSource));
+  const models = /* @__PURE__ */ new Map();
+  const modelNeedle = filters.model?.toLowerCase();
+  for (const account of accounts) {
+    for (const row of account.table?.daily ?? []) {
+      if (firstDay && row.label < firstDay) continue;
+      for (const model of row.breakdown) {
+        if (modelNeedle && !model.name.toLowerCase().includes(modelNeedle)) continue;
+        const key = `${sourceId(account)}\0${model.name}`;
+        let current = models.get(key);
+        if (!current) {
+          current = {
+            sourceId: sourceId(account),
+            providerId: account.providerId,
+            accountId: account.id,
+            model: model.name,
+            ...ZERO_TOTALS()
+          };
+          models.set(key, current);
+        }
+        addUsage(current, {
+          input: model.input,
+          output: model.output,
+          cacheCreate: model.cacheCreate,
+          cacheRead: model.cacheRead,
+          tokens: model.input + model.output + model.cacheCreate + model.cacheRead,
+          cacheSavings: model.cacheSavings,
+          cost: model.cost,
+          calls: model.count
+        });
+      }
+    }
+  }
+  const sorted = [...models.values()].sort((a, b) => b.cost - a.cost || b.tokens - a.tokens || a.model.localeCompare(b.model));
+  const totals = ZERO_TOTALS();
+  for (const model of sorted) addUsage(totals, model);
+  return {
+    schemaVersion: CLI_SCHEMA_VERSION,
+    generatedAt: new Date(snapshot.generatedAt).toISOString(),
+    timezone: snapshot.tz,
+    tokmonConfig,
+    period: filters.period,
+    filters: {
+      provider: filters.provider ?? null,
+      account: filters.account ?? null,
+      model: filters.model ?? null
+    },
+    totals,
+    models: sorted,
+    sources,
+    errors: accounts.filter((account) => account.tableState === "error").map((account) => ({ sourceId: sourceId(account), tableState: account.tableState }))
+  };
+}
+async function buildProvidersReport(snapshot, tokmonConfig) {
+  const providers = await Promise.all(snapshot.accounts.map(async (account) => ({
+    ...await cliSource(account),
+    hasUsage: account.hasUsage,
+    hasBilling: account.hasBilling,
+    plan: account.plan ?? null,
+    summaryState: account.summaryState,
+    tableState: account.tableState,
+    billingState: account.billingState,
+    billingError: account.billing?.error ?? null,
+    metrics: account.billing?.metrics ?? []
+  })));
+  return {
+    schemaVersion: CLI_SCHEMA_VERSION,
+    generatedAt: new Date(snapshot.generatedAt).toISOString(),
+    timezone: snapshot.tz,
+    tokmonConfig,
+    providers
+  };
+}
+var compact = (value) => {
+  const abs = Math.abs(value);
+  if (abs >= 1e9) return `${(value / 1e9).toFixed(2)}B`;
+  if (abs >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
+  if (abs >= 1e3) return `${(value / 1e3).toFixed(1)}K`;
+  return Math.round(value).toString();
+};
+var fit = (value, width) => value.length > width ? `${value.slice(0, Math.max(0, width - 1))}\u2026` : value.padEnd(width);
+function formatUsageReport(report) {
+  const sourceMap = new Map(report.sources.map((source) => [source.id, source]));
+  const lines = [
+    `tokmon usage \xB7 ${report.period} \xB7 ${report.generatedAt} \xB7 ${report.timezone}`,
+    `Tokmon config: ${report.tokmonConfig}`,
+    `${fit("PROVIDER", 12)} ${fit("ACCOUNT", 22)} ${fit("MODEL", 32)} ${"TOKENS".padStart(10)} ${"CALLS".padStart(7)} ${"COST".padStart(10)}`
+  ];
+  if (report.models.length === 0) lines.push("No matching model usage.");
+  for (const model of report.models) {
+    const source = sourceMap.get(model.sourceId);
+    lines.push([
+      fit(source?.provider ?? model.providerId, 12),
+      fit(source?.account ?? model.accountId, 22),
+      fit(model.model, 32),
+      compact(model.tokens).padStart(10),
+      compact(model.calls).padStart(7),
+      `$${model.cost.toFixed(2)}`.padStart(10)
+    ].join(" "));
+  }
+  lines.push("");
+  lines.push(`Total: ${compact(report.totals.tokens)} tokens \xB7 ${compact(report.totals.calls)} calls \xB7 $${report.totals.cost.toFixed(2)}`);
+  lines.push("Sources:");
+  for (const source of report.sources) {
+    const paths = source.locations.filter((item) => item.exists).map((item) => item.path);
+    lines.push(`  ${source.id}  ${paths.join(", ") || source.homeDir || "(no local path found)"}`);
+  }
+  if (report.errors.length) lines.push(`Warnings: ${report.errors.map((error) => `${error.sourceId} ${error.tableState}`).join(", ")}`);
+  return lines.join("\n");
+}
+function formatProvidersReport(report) {
+  const lines = [
+    `tokmon providers \xB7 ${report.generatedAt}`,
+    `Tokmon config: ${report.tokmonConfig}`
+  ];
+  for (const provider of report.providers) {
+    lines.push("");
+    lines.push(`${provider.provider} \xB7 ${provider.account} (${provider.id})`);
+    lines.push(`  usage=${provider.hasUsage ? provider.tableState : "n/a"} billing=${provider.hasBilling ? provider.billingState : "n/a"} plan=${provider.plan ?? "unknown"}`);
+    for (const item of provider.locations) {
+      lines.push(`  ${item.exists ? "\u2713" : "\xB7"} ${item.kind.padEnd(6)} ${item.path}`);
+    }
+    if (provider.billingError) lines.push(`  warning ${provider.billingError}`);
+  }
+  return lines.join("\n");
+}
+
+// src/cli-command.ts
+var QUERY_HELP = `tokmon usage - Query model usage without opening the TUI
+
+Usage:
+  tokmon usage [options]
+  tokmon models [options]       Alias for usage
+  tokmon query [options]        Alias for usage
+
+Options:
+      --period <value>          today | week | month | all (default: month)
+      --provider <id>           Filter by provider (${PROVIDER_IDS.join(", ")})
+      --account <id-or-name>    Filter by account id, name, or email
+      --model <substring>       Filter model names
+      --json                    Stable machine-readable JSON (schemaVersion: 1)
+      --compact                 Emit compact JSON instead of pretty JSON
+      --cached                  Skip the default local-history refresh
+      --refresh                 Refresh all usage and billing before reading
+      --timeout <seconds>       Startup/refresh timeout (default: 45)
+  -h, --help                    Show this help
+
+Examples:
+  tokmon usage
+  tokmon usage --period week --provider codex
+  tokmon usage --model opus --json
+  tokmon usage --period all --json --compact
+`;
+var PROVIDERS_HELP = `tokmon providers - Show detected accounts and their local data/config locations
+
+Usage:
+  tokmon providers [options]
+
+Options:
+      --json                    Stable machine-readable JSON (schemaVersion: 1)
+      --compact                 Emit compact JSON instead of pretty JSON
+      --refresh                 Refresh usage and billing before reading
+      --timeout <seconds>       Startup/refresh timeout (default: 45)
+  -h, --help                    Show this help
+
+Examples:
+  tokmon providers
+  tokmon providers --json
+`;
+var SNAPSHOT_HELP = `tokmon snapshot - Print the daemon's complete raw snapshot as JSON
+
+Usage:
+  tokmon snapshot [options]
+
+Options:
+      --refresh                 Refresh all usage and billing before reading
+      --compact                 Emit compact JSON instead of pretty JSON
+      --timeout <seconds>       Startup/refresh timeout (default: 45)
+  -h, --help                    Show this help
+`;
+var CONFIG_HELP = `tokmon config - Print tokmon's configuration file location
+
+Usage:
+  tokmon config [path]
+  tokmon config --json
+
+Options:
+      --json                    Emit { "path": "..." }
+  -h, --help                    Show this help
+`;
+function valueAfter(args, index, name) {
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) throw new Error(`${name} requires a value`);
+  return [value, index + 1];
+}
+function parseQueryArgs(args) {
+  const parsed = {
+    help: false,
+    json: false,
+    compact: false,
+    refresh: false,
+    cached: false,
+    timeoutMs: 45e3,
+    period: "month",
+    positionals: []
+  };
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--help" || arg === "-h") parsed.help = true;
+    else if (arg === "--json") parsed.json = true;
+    else if (arg === "--compact") parsed.compact = true;
+    else if (arg === "--refresh") parsed.refresh = true;
+    else if (arg === "--cached" || arg === "--no-refresh") parsed.cached = true;
+    else if (arg === "--period") {
+      const [value, next] = valueAfter(args, index, "--period");
+      index = next;
+      if (!USAGE_PERIODS.includes(value)) {
+        throw new Error(`--period must be one of: ${USAGE_PERIODS.join(", ")}`);
+      }
+      parsed.period = value;
+    } else if (arg.startsWith("--period=")) {
+      const value = arg.slice("--period=".length);
+      if (!USAGE_PERIODS.includes(value)) {
+        throw new Error(`--period must be one of: ${USAGE_PERIODS.join(", ")}`);
+      }
+      parsed.period = value;
+    } else if (arg === "--provider") {
+      const [value, next] = valueAfter(args, index, "--provider");
+      index = next;
+      if (!PROVIDER_IDS.includes(value)) throw new Error(`unknown provider: ${value}`);
+      parsed.provider = value;
+    } else if (arg.startsWith("--provider=")) {
+      const value = arg.slice("--provider=".length);
+      if (!PROVIDER_IDS.includes(value)) throw new Error(`unknown provider: ${value}`);
+      parsed.provider = value;
+    } else if (arg === "--account") {
+      [parsed.account, index] = valueAfter(args, index, "--account");
+    } else if (arg.startsWith("--account=")) {
+      parsed.account = arg.slice("--account=".length);
+      if (!parsed.account) throw new Error("--account requires a value");
+    } else if (arg === "--model") {
+      [parsed.model, index] = valueAfter(args, index, "--model");
+    } else if (arg.startsWith("--model=")) {
+      parsed.model = arg.slice("--model=".length);
+      if (!parsed.model) throw new Error("--model requires a value");
+    } else if (arg === "--timeout") {
+      const [value, next] = valueAfter(args, index, "--timeout");
+      index = next;
+      const seconds = Number(value);
+      if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 300) throw new Error("--timeout must be greater than 0 and at most 300 seconds");
+      parsed.timeoutMs = seconds * 1e3;
+    } else if (arg.startsWith("--timeout=")) {
+      const seconds = Number(arg.slice("--timeout=".length));
+      if (!Number.isFinite(seconds) || seconds <= 0 || seconds > 300) throw new Error("--timeout must be greater than 0 and at most 300 seconds");
+      parsed.timeoutMs = seconds * 1e3;
+    } else if (arg.startsWith("-")) throw new Error(`unknown option: ${arg}`);
+    else parsed.positionals.push(arg);
+  }
+  if (parsed.compact) parsed.json = true;
+  if (parsed.refresh && parsed.cached) throw new Error("--refresh and --cached cannot be used together");
+  return parsed;
+}
+function isSnapshot(value) {
+  const snapshot = value;
+  return !!snapshot && typeof snapshot.generatedAt === "number" && typeof snapshot.tz === "string" && Array.isArray(snapshot.accounts) && Array.isArray(snapshot.providers);
+}
+var delay = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+async function fetchDaemonSnapshot(timeoutMs, refresh) {
+  const handle = await attachOrSpawn({ timeoutMs });
+  if (handle.kind !== "spawned" || !handle.baseUrl) throw new Error("tokmon daemon is unavailable");
+  const deadline = Date.now() + timeoutMs;
+  if (refresh) {
+    const client = createDaemonRpcClient(handle.baseUrl, {
+      transport: "node",
+      reconnectAttempts: 2,
+      reconnectBaseDelayMs: 100
+    });
+    try {
+      await withTimeout(client.refresh(refresh), timeoutMs).catch(() => {
+      });
+    } finally {
+      await client.close().catch(() => {
+      });
+    }
+  }
+  while (Date.now() < deadline) {
+    try {
+      const remaining = Math.max(1, deadline - Date.now());
+      const response = await fetch(`${handle.baseUrl}/api/data`, {
+        cache: "no-store",
+        signal: AbortSignal.timeout(Math.min(2e3, remaining))
+      });
+      if (response.ok) {
+        const body = await response.json();
+        if (isSnapshot(body)) return body;
+      }
+    } catch {
+    }
+    await delay(100);
+  }
+  throw new Error(`snapshot unavailable after ${timeoutMs / 1e3}s`);
+}
+function json(value, compact2) {
+  return JSON.stringify(value, null, compact2 ? void 0 : 2) + "\n";
+}
+function rejectsOption(args, names) {
+  for (const arg of args) {
+    const name = names.find((candidate) => arg === candidate || arg.startsWith(`${candidate}=`));
+    if (name) return name;
+  }
+  return null;
+}
+function queryHelp(command) {
+  if (command === "providers") return PROVIDERS_HELP;
+  if (command === "snapshot") return SNAPSHOT_HELP;
+  if (command === "config") return CONFIG_HELP;
+  return QUERY_HELP;
+}
+async function runQueryCommand(command, args, dependencies = {}) {
+  const parsed = parseQueryArgs(args);
+  if (parsed.help) return queryHelp(command);
+  const getConfigPath = dependencies.configPath ?? configLocation;
+  if (command === "config") {
+    const invalid = rejectsOption(args, ["--period", "--provider", "--account", "--model", "--refresh", "--cached", "--no-refresh", "--timeout"]);
+    if (invalid) throw new Error(`${invalid} is not valid for tokmon config`);
+    if (parsed.positionals.length > 1 || parsed.positionals[0] && parsed.positionals[0] !== "path") {
+      throw new Error("usage: tokmon config [path] [--json]");
+    }
+    return parsed.json ? json({ path: getConfigPath() }, parsed.compact) : `${getConfigPath()}
+`;
+  }
+  if (command === "providers" || command === "snapshot") {
+    const invalid = rejectsOption(args, ["--period", "--provider", "--account", "--model", "--cached", "--no-refresh"]);
+    if (invalid) throw new Error(`${invalid} is only valid for tokmon usage`);
+  }
+  if (parsed.positionals.length) throw new Error(`unexpected argument: ${parsed.positionals[0]}`);
+  const usageCommand = command === "usage" || command === "models" || command === "query";
+  const refresh = parsed.refresh ? "all" : usageCommand && !parsed.cached ? "table" : null;
+  const snapshot = await (dependencies.fetchSnapshot ?? fetchDaemonSnapshot)(parsed.timeoutMs, refresh);
+  if (command === "snapshot") return json(snapshot, parsed.compact);
+  if (command === "providers") {
+    const report2 = await buildProvidersReport(snapshot, getConfigPath());
+    return parsed.json ? json(report2, parsed.compact) : `${formatProvidersReport(report2)}
+`;
+  }
+  const filters = {
+    period: parsed.period,
+    provider: parsed.provider,
+    account: parsed.account,
+    model: parsed.model
+  };
+  const report = await buildUsageReport(snapshot, filters, Date.now(), getConfigPath());
+  return parsed.json ? json(report, parsed.compact) : `${formatUsageReport(report)}
+`;
+}
+export {
+  fetchDaemonSnapshot,
+  parseQueryArgs,
+  queryHelp,
+  runQueryCommand
+};

package/dist/cli.js

@@ -40,15 +40,34 @@ function validateServeArgs(serveArgs) {
   }
 }
 async function main() {
+  if (subcommand && ["usage", "models", "query", "providers", "snapshot", "config"].includes(subcommand)) {
+    const { runQueryCommand } = await import("./cli-command-TLGIGF63.js");
+    try {
+      const output = await runQueryCommand(
+        subcommand,
+        args.slice(1)
+      );
+      process.stdout.write(output);
+      process.exitCode ??= 0;
+    } catch (error) {
+      const message = describeError(error);
+      if (args.includes("--json")) process.stderr.write(JSON.stringify({ error: message }) + "\n");
+      else process.stderr.write(`tokmon ${subcommand}: ${message}
+Run tokmon ${subcommand} --help for usage.
+`);
+      process.exitCode = 1;
+    }
+    return;
+  }
   if (subcommand === "__daemon") {
-    const { runDaemon } = await import("./daemon-PVYTXJMS.js");
+    const { runDaemon } = await import("./daemon-F4EGY77J.js");
     await runDaemon(args.slice(1), { foreground: false });
     process.exitCode ??= 0;
     return;
   }
   if (subcommand === "serve" || subcommand === "web") {
     validateServeArgs(args.slice(1));
-    const { runDaemon } = await import("./daemon-PVYTXJMS.js");
+    const { runDaemon } = await import("./daemon-F4EGY77J.js");
     await runDaemon(args.slice(1), { foreground: true });
     process.exitCode ??= 0;
     return;
@@ -71,6 +90,12 @@ async function main() {
       console.log("  Claude \xB7 Codex \xB7 Cursor \xB7 Copilot \xB7 opencode \xB7 pi \xB7 Antigravity \xB7 Gemini \xB7 Grok\n");
       console.log("Usage: tokmon [options]");
       console.log("       tokmon serve [--port <n>] [--no-open]   Launch the web dashboard\n");
+      console.log("Data commands:");
+      console.log("  tokmon usage [--period month] [--json]       Query usage by model");
+      console.log("  tokmon providers [--json]                    Show providers and local paths");
+      console.log("  tokmon snapshot [--refresh]                  Print the raw daemon snapshot");
+      console.log("  tokmon config [path]                         Print the config file location");
+      console.log("  Run tokmon <command> --help for all filters and examples.\n");
       console.log("Options:");
       console.log("  -i, --interval <seconds>  Refresh interval (default: from config or 2)");
       console.log("      --ascii               Force ASCII glyphs (also: TOKMON_ASCII=1)");
@@ -92,7 +117,7 @@ async function main() {
   }
   const { loadConfig } = await import("./config-QC5QSP3G.js");
   const { resolveGlyphs, setGlyphs } = await import("./glyphs-NKCSZLGO.js");
-  const { attachOrSpawn } = await import("./daemon-handle-Y2N2NA6D.js");
+  const { attachOrSpawn } = await import("./daemon-handle-NLCLYWFU.js");
   const config = await loadConfig();
   setGlyphs(resolveGlyphs({
     flag: asciiFlag,
@@ -103,7 +128,7 @@ async function main() {
   }));
   const daemon = await attachOrSpawn();
   const mode = daemon.kind === "spawned" ? "connected" : "degraded";
-  const { bootstrapInk } = await import("./bootstrap-ink-WA3ENW2M.js");
+  const { bootstrapInk } = await import("./bootstrap-ink-HL2BYNW3.js");
   await bootstrapInk({ interval, config, daemon, mode });
 }
 void main().catch((error) => {

package/dist/{daemon-PVYTXJMS.js → daemon-F4EGY77J.js}

@@ -1,7 +1,4 @@
 #!/usr/bin/env node
-import {
-  startWebServer
-} from "./chunk-MJWFCDBB.js";
 import {
   acquireLock,
   isAlive,
@@ -12,12 +9,16 @@ import {
   verifyLock,
   writeLock
 } from "./chunk-3TJVFKXV.js";
+import {
+  startWebServer
+} from "./chunk-REO4O5VE.js";
 import {
   appVersion
 } from "./chunk-SMPY52EV.js";
+import "./chunk-42H7R376.js";
 import {
   flushDisk
-} from "./chunk-IELQ5EY3.js";
+} from "./chunk-O27I2XFN.js";
 import {
   loadConfig
 } from "./chunk-5CWOJMAH.js";

package/dist/daemon-handle-NLCLYWFU.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  attachOrSpawn
+} from "./chunk-W2WGBXZG.js";
+import "./chunk-3TJVFKXV.js";
+import "./chunk-SMPY52EV.js";
+import "./chunk-5CWOJMAH.js";
+export {
+  attachOrSpawn
+};

package/dist/{server-XUCQWX6N.js → server-X63FGHIZ.js}

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import {
   startWebServer
-} from "./chunk-MJWFCDBB.js";
+} from "./chunk-REO4O5VE.js";
 import "./chunk-SMPY52EV.js";
-import "./chunk-IELQ5EY3.js";
+import "./chunk-42H7R376.js";
+import "./chunk-O27I2XFN.js";
 import "./chunk-5CWOJMAH.js";
 export {
   startWebServer