tokmon 0.28.1 → 0.28.3

package/dist/chunk-USKOQIE3.js

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+import {
+  daemonChannelFromWire,
+  resolveDaemonChannel
+} from "./chunk-UYPDMVW5.js";
+import {
+  cacheDir
+} from "./chunk-HNWEJ6MS.js";
+
+// src/web/lockfile.ts
+import { closeSync, fchmodSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { isAbsolute, join } from "path";
+function lockDir(opts = {}) {
+  const injected = opts.cachePath ?? process.env.TOKMON_DAEMON_CACHE_DIR;
+  if (injected && isAbsolute(injected)) return injected;
+  const root = cacheDir();
+  return resolveDaemonChannel(opts.channel) === "dev" ? join(root, "dev") : root;
+}
+function lockfilePath(opts = {}) {
+  return join(lockDir(opts), "daemon.json");
+}
+function isLoopbackUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
+function validLock(value) {
+  const lock = value;
+  return !!lock && typeof lock.pid === "number" && Number.isInteger(lock.pid) && lock.pid > 0 && typeof lock.port === "number" && Number.isInteger(lock.port) && lock.port >= 0 && lock.port <= 65535 && typeof lock.url === "string" && (lock.state === "starting" || isLoopbackUrl(lock.url)) && typeof lock.wsToken === "string" && lock.wsToken.length >= 32 && typeof lock.version === "string" && typeof lock.protocolVersion === "number" && Number.isSafeInteger(lock.protocolVersion) && lock.protocolVersion >= 1 && Array.isArray(lock.capabilities) && lock.capabilities.every((capability) => typeof capability === "string") && (lock.ownerKind === "cli" || lock.ownerKind === "desktop") && daemonChannelFromWire(lock.channel) !== null && typeof lock.startedAt === "number" && typeof lock.ownerId === "string" && lock.ownerId.length >= 32 && (lock.state === "starting" || lock.state === "ready");
+}
+function readLock(opts = {}) {
+  try {
+    const path = lockfilePath(opts);
+    const stat = statSync(path);
+    if (!stat.isFile() || (stat.mode & 63) !== 0) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (!validLock(parsed)) return null;
+    const channel = daemonChannelFromWire(parsed.channel);
+    return channel === resolveDaemonChannel(opts.channel) ? { ...parsed, channel } : null;
+  } catch {
+    return null;
+  }
+}
+function readForeignLock(opts = {}) {
+  try {
+    const path = lockfilePath(opts);
+    const stat = statSync(path);
+    if (!stat.isFile() || (stat.mode & 63) !== 0) return null;
+    const value = JSON.parse(readFileSync(path, "utf-8"));
+    const channel = daemonChannelFromWire(value.channel);
+    if (!Number.isInteger(value.pid) || value.pid <= 0 || typeof value.url !== "string" || !isLoopbackUrl(value.url) || typeof value.wsToken !== "string" || value.wsToken.length < 32 || value.state !== "ready" || channel !== resolveDaemonChannel(opts.channel)) return null;
+    if (value.ownerKind !== void 0 && value.ownerKind !== "cli" && value.ownerKind !== "desktop") return null;
+    if (value.protocolVersion !== void 0 && (!Number.isSafeInteger(value.protocolVersion) || value.protocolVersion < 1)) return null;
+    return {
+      pid: value.pid,
+      ...Number.isInteger(value.port) ? { port: value.port } : {},
+      url: value.url,
+      wsToken: value.wsToken,
+      ...typeof value.version === "string" ? { version: value.version } : {},
+      ...typeof value.protocolVersion === "number" ? { protocolVersion: value.protocolVersion } : {},
+      ...Array.isArray(value.capabilities) && value.capabilities.every((item) => typeof item === "string") ? { capabilities: value.capabilities } : {},
+      ...value.ownerKind === "cli" || value.ownerKind === "desktop" ? { ownerKind: value.ownerKind } : {},
+      channel,
+      ...typeof value.startedAt === "number" ? { startedAt: value.startedAt } : {},
+      ...typeof value.ownerId === "string" ? { ownerId: value.ownerId } : {},
+      state: "ready"
+    };
+  } catch {
+    return null;
+  }
+}
+function ensureLockDir(opts) {
+  const dir = lockDir(opts);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  let fd;
+  try {
+    fd = openSync(dir, "r");
+    fchmodSync(fd, 448);
+  } catch {
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function writeNew(path, lock) {
+  let fd;
+  let created = false;
+  try {
+    fd = openSync(path, "wx", 384);
+    created = true;
+    fchmodSync(fd, 384);
+    writeFileSync(fd, JSON.stringify(lock));
+    fsyncSync(fd);
+    return true;
+  } catch {
+    if (created) try {
+      unlinkSync(path);
+    } catch {
+    }
+    return false;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function acquireLock(lock, opts = {}) {
+  if (lock.channel !== resolveDaemonChannel(opts.channel)) return false;
+  try {
+    ensureLockDir(opts);
+    return writeNew(lockfilePath(opts), lock);
+  } catch {
+    return false;
+  }
+}
+function writeLock(lock, opts = {}) {
+  const current = readLock(opts);
+  if (!current || current.ownerId !== lock.ownerId || current.pid !== process.pid || lock.channel !== current.channel) return false;
+  const path = lockfilePath(opts);
+  const tmp = join(lockDir(opts), `daemon.json.${process.pid}.${lock.ownerId}.tmp`);
+  let fd;
+  try {
+    writeFileSync(tmp, JSON.stringify(lock), { mode: 384 });
+    try {
+      fd = openSync(tmp, "r");
+      fchmodSync(fd, 384);
+      fsyncSync(fd);
+    } catch {
+    }
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    return false;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function unlinkLock(ownerId, opts = {}) {
+  const current = readLock(opts);
+  if (!current || current.ownerId !== ownerId || current.pid !== process.pid) return false;
+  try {
+    unlinkSync(lockfilePath(opts));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reclaimDeadLock(opts = {}) {
+  const current = readLock(opts);
+  if (!current || isAlive(current.pid)) return false;
+  try {
+    unlinkSync(lockfilePath(opts));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reclaimAbandonedLock(opts = {}, graceMs = 1e4) {
+  const path = lockfilePath(opts);
+  try {
+    const before = lstatSync(path);
+    if (!before.isFile()) return false;
+    let pid = null;
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8"));
+      if (Number.isInteger(parsed.pid) && parsed.pid > 0) pid = parsed.pid;
+    } catch {
+    }
+    if (pid !== null && isAlive(pid)) return false;
+    if (pid === null && Date.now() - before.mtimeMs < graceMs) return false;
+    const after = lstatSync(path);
+    if (after.dev !== before.dev || after.ino !== before.ino) return false;
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function sameCapabilities(actual, expected) {
+  return Array.isArray(actual) && actual.length === expected.length && actual.every((capability, index) => capability === expected[index]);
+}
+async function ownerHealth(url, token, timeoutMs = 500) {
+  if (!isLoopbackUrl(url) || !token) return null;
+  try {
+    const res = await fetch(`${url.replace(/\/+$/, "")}/healthz`, {
+      headers: { "x-tokmon-token": token },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function probeHealth(url, token, expected = {}, timeoutMs = 500) {
+  const body = await ownerHealth(url, token, timeoutMs);
+  const bodyChannel = daemonChannelFromWire(body?.channel);
+  return body !== null && body.ok === true && body.owner === true && (expected.version === void 0 || body.version === expected.version) && (expected.protocolVersion === void 0 || body.protocolVersion === expected.protocolVersion) && (expected.capabilities === void 0 || sameCapabilities(body.capabilities, expected.capabilities)) && (expected.ownerKind === void 0 || body.ownerKind === expected.ownerKind) && (expected.channel === void 0 || bodyChannel === expected.channel);
+}
+async function verifyLock(lock, protocolVersion, timeoutMs) {
+  if (!lock || lock.state !== "ready" || lock.protocolVersion !== protocolVersion || !isAlive(lock.pid)) return null;
+  return await probeHealth(lock.url, lock.wsToken, lock, timeoutMs) ? lock : null;
+}
+var TAKEOVER_TIMEOUT_MS = 5e3;
+var takeoverDelay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function sameForeignOwner(left, right) {
+  return left.pid === right.pid && left.wsToken === right.wsToken && left.ownerId === right.ownerId;
+}
+async function retireIncompatibleCliOwner(opts, protocolVersion, timeoutMs = TAKEOVER_TIMEOUT_MS) {
+  const compatible = readLock(opts);
+  if (compatible?.protocolVersion === protocolVersion) return false;
+  const foreign = readForeignLock(opts);
+  const legacyCli = foreign?.ownerKind === void 0 && foreign?.protocolVersion === void 0;
+  if (!foreign || foreign.state !== "ready" || foreign.ownerKind === "desktop" || foreign.ownerKind !== "cli" && !legacyCli || foreign.pid === process.pid || !isAlive(foreign.pid)) return false;
+  const health = await ownerHealth(foreign.url, foreign.wsToken, Math.min(1e3, timeoutMs));
+  const healthChannel = daemonChannelFromWire(health?.channel);
+  if (health?.ok !== true || health.owner !== true || health.ownerKind !== void 0 && health.ownerKind !== "cli" || healthChannel !== foreign.channel) return false;
+  try {
+    process.kill(foreign.pid, "SIGTERM");
+  } catch {
+    if (!isAlive(foreign.pid)) {
+      reclaimAbandonedLock(opts, 0);
+      return true;
+    }
+    return false;
+  }
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() < deadline) {
+    const current = readForeignLock(opts);
+    if (!current || !sameForeignOwner(current, foreign)) return true;
+    if (!isAlive(foreign.pid)) {
+      reclaimAbandonedLock(opts, 0);
+      return true;
+    }
+    await takeoverDelay(50);
+  }
+  if (!isAlive(foreign.pid)) {
+    reclaimAbandonedLock(opts, 0);
+    return true;
+  }
+  return false;
+}
+
+export {
+  lockfilePath,
+  readLock,
+  readForeignLock,
+  acquireLock,
+  writeLock,
+  unlinkLock,
+  reclaimDeadLock,
+  reclaimAbandonedLock,
+  isAlive,
+  verifyLock,
+  retireIncompatibleCliOwner
+};

package/dist/chunk-UYPDMVW5.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+// src/web/daemon-channel.ts
+var RELEASE_DAEMON_CHANNEL = "release";
+var DEV_DAEMON_CHANNEL = "dev";
+function resolveDaemonChannel(explicit, env = process.env) {
+  if (explicit) return explicit;
+  const configured = env.TOKMON_CHANNEL ?? env.TOKMON_RUNTIME_CHANNEL ?? env.TOKMON_RUNTIME_TAG;
+  return configured === DEV_DAEMON_CHANNEL ? DEV_DAEMON_CHANNEL : RELEASE_DAEMON_CHANNEL;
+}
+function daemonChannelFromWire(value) {
+  if (value === void 0) return RELEASE_DAEMON_CHANNEL;
+  if (value === RELEASE_DAEMON_CHANNEL) return RELEASE_DAEMON_CHANNEL;
+  if (value === DEV_DAEMON_CHANNEL) return DEV_DAEMON_CHANNEL;
+  return null;
+}
+
+export {
+  resolveDaemonChannel,
+  daemonChannelFromWire
+};

package/dist/{cli-command-75LP4IDS.js → cli-command-MD3RJRP4.js}

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import {
   attachOrSpawn
-} from "./chunk-4HU4EI5T.js";
-import "./chunk-XDA5RJST.js";
-import "./chunk-SMPY52EV.js";
+} from "./chunk-P5JN5DDX.js";
+import "./chunk-USKOQIE3.js";
+import "./chunk-UYPDMVW5.js";
 import {
   createDaemonRpcClient
-} from "./chunk-3RTWFGGD.js";
+} from "./chunk-7CH6S7BR.js";
 import {
   PROVIDERS,
   antigravityStateDb,
@@ -26,11 +26,13 @@ import {
   startOfMonth,
   startOfWeek,
   withTimeout
-} from "./chunk-CVKCVHS7.js";
+} from "./chunk-CFKUZCMB.js";
+import "./chunk-JZSZEHVD.js";
 import {
+  DESKTOP_GRAPH_RANGES,
   PROVIDER_IDS,
   configLocation
-} from "./chunk-HP5UZCXP.js";
+} from "./chunk-HNWEJ6MS.js";
 
 // src/provider-locations.ts
 import { access } from "fs/promises";
@@ -133,7 +135,7 @@ async function cliSource(account) {
     providerId: account.providerId,
     provider: PROVIDERS[account.providerId].name,
     accountId: account.id,
-    account: account.email || account.displayName || account.name,
+    account: account.identity?.accessibleLabel ?? (account.email || account.displayName || account.name),
     homeDir: account.homeDir,
     locations: await providerLocations(account.providerId, account.homeDir ?? void 0)
   };
@@ -341,15 +343,38 @@ Options:
       --timeout <seconds>       Startup/refresh timeout (default: 45)
   -h, --help                    Show this help
 `;
-var CONFIG_HELP = `tokmon config - Print tokmon's configuration file location
+var CONFIG_HELP = `tokmon config - Read and update tokmon settings
 
 Usage:
   tokmon config [path]
   tokmon config --json
+  tokmon config get [--json]
+  tokmon config set <setting> <value> [--json]
+
+Settings:
+  privacy <on|off>
+  privacy-key <char>
+  menu-bar-pins <ids|none>       Comma-separated provider ids; at most 2
+  menu-bar-text <on|off>
+  summary-mode <smart|tightest>
+  expanded-providers <ids|none>  Comma-separated provider ids
+  active-window <minutes>        1..1440
+  graph-range <7|14|30>          Desktop spend graph days
+  auto-detect <on|off>           Automatic account discovery
+  auto-detect-providers <ids|none>
+  launch-at-login <on|off>
 
 Options:
-      --json                    Emit { "path": "..." }
+      --json                    Emit machine-readable JSON
+      --compact                 Emit compact JSON
+      --timeout <seconds>       Daemon connection timeout (default: 45)
   -h, --help                    Show this help
+
+Examples:
+  tokmon config get
+  tokmon config set privacy off
+  tokmon config set menu-bar-pins claude,codex
+  tokmon config set summary-mode smart --json
 `;
 function valueAfter(args, index, name) {
   const value = args[index + 1];
@@ -430,6 +455,15 @@ function isSnapshot(value) {
 var delay = (ms) => new Promise((resolve) => {
   setTimeout(resolve, ms);
 });
+async function connectDaemonConfig(timeoutMs) {
+  const handle = await attachOrSpawn({ timeoutMs });
+  if (handle.kind !== "spawned" || !handle.baseUrl) throw new Error("tokmon daemon is unavailable");
+  return createDaemonRpcClient(handle.baseUrl, {
+    transport: "node",
+    reconnectAttempts: 2,
+    reconnectBaseDelayMs: 100
+  });
+}
 async function fetchDaemonSnapshot(timeoutMs, refresh) {
   const handle = await attachOrSpawn({ timeoutMs });
   if (handle.kind !== "spawned" || !handle.baseUrl) throw new Error("tokmon daemon is unavailable");
@@ -475,6 +509,209 @@ function rejectsOption(args, names) {
   }
   return null;
 }
+var CONFIG_SETTINGS = [
+  "privacy",
+  "privacy-key",
+  "menu-bar-pins",
+  "menu-bar-text",
+  "summary-mode",
+  "expanded-providers",
+  "active-window",
+  "graph-range",
+  "auto-detect",
+  "auto-detect-providers",
+  "launch-at-login"
+];
+function configReport(config) {
+  return {
+    revision: config.revision,
+    privacy: config.privacyMode ? "on" : "off",
+    privacyKey: config.privacyToggleKey,
+    menuBarPins: [...config.tray.pinnedProviders],
+    menuBarText: config.tray.showMenuBarText ? "on" : "off",
+    summaryMode: config.tray.displayMetric === "smartHeadroom" ? "smart" : "tightest",
+    expandedProviders: [...config.desktop.expandedProviders],
+    activeWindowMinutes: config.tray.activeTimeoutMin,
+    graphRangeDays: config.desktop.graphRangeDays,
+    autoDetect: config.accountDetection.enabled ? "on" : "off",
+    autoDetectProviders: PROVIDER_IDS.filter((id) => !config.accountDetection.disabledProviders.includes(id)),
+    launchAtLogin: config.tray.launchAtLogin ? "on" : "off"
+  };
+}
+function formatConfigReport(report) {
+  const list = (values) => values.length > 0 ? values.join(",") : "none";
+  return [
+    `privacy             ${report.privacy}`,
+    `privacy-key         ${report.privacyKey}`,
+    `menu-bar-pins       ${list(report.menuBarPins)}`,
+    `menu-bar-text       ${report.menuBarText}`,
+    `summary-mode        ${report.summaryMode}`,
+    `expanded-providers  ${list(report.expandedProviders)}`,
+    `active-window       ${report.activeWindowMinutes}m`,
+    `graph-range         ${report.graphRangeDays}d`,
+    `auto-detect         ${report.autoDetect}`,
+    `auto-detect-providers ${list(report.autoDetectProviders)}`,
+    `launch-at-login     ${report.launchAtLogin}`
+  ].join("\n") + "\n";
+}
+function onOff(value, setting) {
+  if (value === "on") return true;
+  if (value === "off") return false;
+  throw new Error(`${setting} must be on or off`);
+}
+function providerList(value, setting, max = PROVIDER_IDS.length) {
+  if (value === "none") return [];
+  const raw = value.split(",").map((item) => item.trim());
+  if (raw.length === 0 || raw.some((item) => item.length === 0)) {
+    throw new Error(`${setting} must be a comma-separated provider list or none`);
+  }
+  const unique2 = [...new Set(raw)];
+  for (const provider of unique2) {
+    if (!PROVIDER_IDS.includes(provider)) throw new Error(`unknown provider: ${provider}`);
+  }
+  if (unique2.length > max) throw new Error(`${setting} accepts at most ${max} providers`);
+  return unique2;
+}
+function settingMutation(setting, value) {
+  if (setting === "privacy") {
+    const enabled2 = onOff(value, setting);
+    return { mutate: (config) => ({ ...config, privacyMode: enabled2 }), display: value };
+  }
+  if (setting === "privacy-key") {
+    if (value.length !== 1 || new RegExp("\\s|\\p{Cc}", "u").test(value)) throw new Error("privacy-key must be one printable non-whitespace character");
+    return { mutate: (config) => ({ ...config, privacyToggleKey: value }), display: value };
+  }
+  if (setting === "menu-bar-pins") {
+    const providers = providerList(value, setting, 2);
+    return {
+      mutate: (config) => ({
+        ...config,
+        tray: { ...config.tray, pinnedProviders: providers, pins: [], pinnedAccount: null }
+      }),
+      display: providers
+    };
+  }
+  if (setting === "menu-bar-text") {
+    const enabled2 = onOff(value, setting);
+    return { mutate: (config) => ({ ...config, tray: { ...config.tray, showMenuBarText: enabled2 } }), display: value };
+  }
+  if (setting === "summary-mode") {
+    if (value !== "smart" && value !== "tightest") throw new Error("summary-mode must be smart or tightest");
+    const displayMetric = value === "smart" ? "smartHeadroom" : "tightestRemaining";
+    return { mutate: (config) => ({ ...config, tray: { ...config.tray, displayMetric } }), display: value };
+  }
+  if (setting === "expanded-providers") {
+    const providers = providerList(value, setting);
+    return {
+      mutate: (config) => ({ ...config, desktop: { ...config.desktop, expandedProviders: providers } }),
+      display: providers
+    };
+  }
+  if (setting === "active-window") {
+    const minutes = Number(value);
+    if (!Number.isInteger(minutes) || minutes < 1 || minutes > 1440) throw new Error("active-window must be an integer from 1 to 1440 minutes");
+    return { mutate: (config) => ({ ...config, tray: { ...config.tray, activeTimeoutMin: minutes } }), display: minutes };
+  }
+  if (setting === "graph-range") {
+    const days = Number(value);
+    if (!DESKTOP_GRAPH_RANGES.includes(days)) throw new Error("graph-range must be 7, 14, or 30 days");
+    return {
+      mutate: (config) => ({ ...config, desktop: { ...config.desktop, graphRangeDays: days } }),
+      display: days
+    };
+  }
+  if (setting === "auto-detect") {
+    const enabled2 = onOff(value, setting);
+    return {
+      mutate: (config) => ({ ...config, accountDetection: { ...config.accountDetection, enabled: enabled2 } }),
+      display: value
+    };
+  }
+  if (setting === "auto-detect-providers") {
+    const enabled2 = providerList(value, setting);
+    return {
+      mutate: (config) => ({
+        ...config,
+        accountDetection: {
+          ...config.accountDetection,
+          disabledProviders: PROVIDER_IDS.filter((provider) => !enabled2.includes(provider))
+        }
+      }),
+      display: enabled2
+    };
+  }
+  if (setting !== "launch-at-login") throw new Error(`unsupported config setting: ${setting}`);
+  const enabled = onOff(value, setting);
+  return { mutate: (config) => ({ ...config, tray: { ...config.tray, launchAtLogin: enabled } }), display: value };
+}
+function isConfigConflict(cause) {
+  return !!cause && typeof cause === "object" && cause.kind === "conflict";
+}
+async function readDaemonConfig(timeoutMs, connect) {
+  const client = await connect(timeoutMs);
+  try {
+    const state = await withTimeout(client.getConfig(), timeoutMs);
+    return {
+      state,
+      close: () => client.close(),
+      get: () => withTimeout(client.getConfig(), timeoutMs),
+      set: (update) => withTimeout(client.setConfig(update), timeoutMs)
+    };
+  } catch (cause) {
+    await client.close().catch(() => {
+    });
+    throw cause;
+  }
+}
+async function runConfigCommand(args, configPath, connect) {
+  const [action, settingName, value, ...extra] = args.positionals;
+  if (!action || action === "path") {
+    if (settingName || value || extra.length > 0) throw new Error("usage: tokmon config [path] [--json]");
+    return args.json ? json({ path: configPath() }, args.compact) : `${configPath()}
+`;
+  }
+  if (action !== "get" && action !== "set") throw new Error("usage: tokmon config [path|get|set]");
+  if (action === "get") {
+    if (settingName || value || extra.length > 0) throw new Error("usage: tokmon config get [--json]");
+    const daemon2 = await readDaemonConfig(args.timeoutMs, connect);
+    try {
+      const report = configReport(daemon2.state.config);
+      return args.json ? json(report, args.compact) : formatConfigReport(report);
+    } finally {
+      await daemon2.close().catch(() => {
+      });
+    }
+  }
+  if (!settingName || !CONFIG_SETTINGS.includes(settingName) || value === void 0 || extra.length > 0) {
+    throw new Error("usage: tokmon config set <setting> <value>");
+  }
+  const setting = settingName;
+  const update = settingMutation(setting, value);
+  const daemon = await readDaemonConfig(args.timeoutMs, connect);
+  try {
+    let base = daemon.state;
+    let saved = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        saved = await daemon.set({
+          expectedRevision: base.config.revision,
+          config: update.mutate(base.config)
+        });
+        break;
+      } catch (cause) {
+        if (attempt > 0 || !isConfigConflict(cause)) throw cause;
+        base = await daemon.get();
+      }
+    }
+    if (!saved) throw new Error("config update failed");
+    const result = { setting, value: update.display, revision: saved.config.revision };
+    return args.json ? json(result, args.compact) : `${setting} ${Array.isArray(update.display) ? update.display.join(",") || "none" : update.display}
+`;
+  } finally {
+    await daemon.close().catch(() => {
+    });
+  }
+}
 function queryHelp(command) {
   if (command === "providers") return PROVIDERS_HELP;
   if (command === "snapshot") return SNAPSHOT_HELP;
@@ -486,13 +723,9 @@ async function runQueryCommand(command, args, dependencies = {}) {
   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"]);
+    const invalid = rejectsOption(args, ["--period", "--provider", "--account", "--model", "--refresh", "--cached", "--no-refresh"]);
     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()}
-`;
+    return runConfigCommand(parsed, getConfigPath, dependencies.connectConfig ?? connectDaemonConfig);
   }
   if (command === "providers" || command === "snapshot") {
     const invalid = rejectsOption(args, ["--period", "--provider", "--account", "--model", "--cached", "--no-refresh"]);
@@ -519,6 +752,7 @@ async function runQueryCommand(command, args, dependencies = {}) {
 `;
 }
 export {
+  connectDaemonConfig,
   fetchDaemonSnapshot,
   parseQueryArgs,
   queryHelp,

package/dist/cli.js

@@ -41,7 +41,7 @@ function validateServeArgs(serveArgs) {
 }
 async function main() {
   if (subcommand && ["usage", "models", "query", "providers", "snapshot", "config"].includes(subcommand)) {
-    const { runQueryCommand } = await import("./cli-command-75LP4IDS.js");
+    const { runQueryCommand } = await import("./cli-command-MD3RJRP4.js");
     try {
       const output = await runQueryCommand(
         subcommand,
@@ -60,14 +60,14 @@ Run tokmon ${subcommand} --help for usage.
     return;
   }
   if (subcommand === "__daemon") {
-    const { runDaemon } = await import("./daemon-CL4FJW26.js");
+    const { runDaemon } = await import("./daemon-EMOA36WB.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-CL4FJW26.js");
+    const { runDaemon } = await import("./daemon-EMOA36WB.js");
     await runDaemon(args.slice(1), { foreground: true });
     process.exitCode ??= 0;
     return;
@@ -115,9 +115,9 @@ Run tokmon ${subcommand} --help for usage.
       return;
     }
   }
-  const { loadConfig } = await import("./config-HXFJTNLM.js");
+  const { loadConfig } = await import("./config-3DGZ47F7.js");
   const { resolveGlyphs, setGlyphs } = await import("./glyphs-NKCSZLGO.js");
-  const { attachOrSpawn } = await import("./daemon-handle-QQLJE46Y.js");
+  const { attachOrSpawn } = await import("./daemon-handle-JHE5MKMI.js");
   const config = await loadConfig();
   setGlyphs(resolveGlyphs({
     flag: asciiFlag,
@@ -128,7 +128,7 @@ Run tokmon ${subcommand} --help for usage.
   }));
   const daemon = await attachOrSpawn();
   const mode = daemon.kind === "spawned" ? "connected" : "degraded";
-  const { bootstrapInk } = await import("./bootstrap-ink-L7QSJBMS.js");
+  const { bootstrapInk } = await import("./bootstrap-ink-WG4WG3R2.js");
   await bootstrapInk({ interval, config, daemon, mode });
 }
 void main().catch((error) => {