tokmon 0.23.4 → 0.24.0

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
+};

package/dist/chunk-45ZP755H.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import {
+  TOKMON_WS_METHODS,
+  TOKMON_WS_PATH,
+  TokmonRpcGroup
+} from "./chunk-O27I2XFN.js";
+
+// 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(() => {
+        });
+      }
+    }
+  };
+}
+
+export {
+  createDaemonRpcClient
+};

package/dist/{chunk-DJPUYMZM.js → chunk-5CWOJMAH.js}

@@ -25,6 +25,7 @@ var DEFAULTS = {
   dashboardLayout: "grid",
   defaultFocus: "all",
   ascii: "auto",
+  allowNetworkAccess: false,
   knownProviders: []
 };
 var LEGACY_KNOWN = ["claude", "codex", "cursor"];
@@ -214,6 +215,7 @@ function repairConfig(input) {
     dashboardLayout: parsed.dashboardLayout === "single" ? "single" : "grid",
     defaultFocus: parsed.defaultFocus === "last" ? "last" : "all",
     ascii: parsed.ascii === "on" ? "on" : parsed.ascii === "off" ? "off" : "auto",
+    allowNetworkAccess: parsed.allowNetworkAccess === true,
     knownProviders
   };
   for (const key of Object.keys(DEFAULTS)) {