tokmon 0.28.2 → 0.28.3

package/dist/chunk-HP5UZCXP.js

@@ -1,436 +0,0 @@
-#!/usr/bin/env node
-
-// src/config.ts
-import { chmod, readFile, writeFile, mkdir, rename, unlink } from "fs/promises";
-import { chmodSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
-import { join, isAbsolute } from "path";
-import { homedir } from "os";
-
-// src/providers/types.ts
-var PROVIDER_IDS = ["claude", "codex", "cursor", "copilot", "pi", "opencode", "antigravity", "gemini", "grok"];
-
-// src/config-schema.ts
-var DEFAULTS = {
-  revision: 0,
-  interval: 2,
-  billingInterval: 5,
-  clearScreen: true,
-  privacyMode: true,
-  privacyToggleKey: "p",
-  timezone: null,
-  accounts: [],
-  activeAccountId: null,
-  disabledProviders: [],
-  onboarded: false,
-  dashboardLayout: "grid",
-  defaultFocus: "all",
-  ascii: "auto",
-  allowNetworkAccess: false,
-  allowedHosts: [],
-  resetDisplay: "relative",
-  knownProviders: []
-};
-var LEGACY_KNOWN = ["claude", "codex", "cursor"];
-var ACCENT_COLORS = ["cyan", "magenta", "green", "yellow", "blue", "red"];
-var PROVIDER_ORDER = [...PROVIDER_IDS];
-var COLOR_PALETTE = [
-  "cyan",
-  "magenta",
-  "green",
-  "yellow",
-  "blue",
-  "red",
-  "cyanBright",
-  "magentaBright",
-  "greenBright"
-];
-var PROVIDER_META = {
-  claude: { name: "Claude", color: "green" },
-  codex: { name: "Codex", color: "cyan" },
-  cursor: { name: "Cursor", color: "magenta" },
-  copilot: { name: "Copilot", color: "white" },
-  pi: { name: "Pi", color: "blue" },
-  opencode: { name: "opencode", color: "yellow" },
-  antigravity: { name: "Antigravity", color: "red" },
-  gemini: { name: "Gemini", color: "greenBright" },
-  grok: { name: "Grok", color: "yellowBright" }
-};
-var EMAIL_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
-var EMAIL_RE_GLOBAL = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
-function containsEmail(value) {
-  return typeof value === "string" && EMAIL_RE.test(value);
-}
-function redactEmail(value) {
-  return value.replace(EMAIL_RE_GLOBAL, "[redacted]");
-}
-function getTrackedAccountRows(config, trackedProviders = PROVIDER_ORDER.filter((pid) => !config.disabledProviders.includes(pid)), autoAccounts) {
-  const tracked = new Set(trackedProviders);
-  const configuredIds = /* @__PURE__ */ new Set();
-  const configuredKeys = /* @__PURE__ */ new Set();
-  const rowIds = /* @__PURE__ */ new Set();
-  const rowKeys = /* @__PURE__ */ new Set();
-  const rows = [];
-  const keyFor = (providerId, homeDir) => `${providerId}:${homeDir && homeDir !== "~" ? homeDir : "~"}`;
-  const rememberRow = (row) => {
-    rowIds.add(row.id);
-    rowKeys.add(keyFor(row.providerId, row.homeDir));
-    rows.push(row);
-  };
-  config.accounts.forEach((account, explicitIndex) => {
-    const meta = PROVIDER_META[account.providerId];
-    configuredIds.add(account.id);
-    configuredKeys.add(keyFor(account.providerId, account.homeDir));
-    rememberRow({
-      id: account.id,
-      providerId: account.providerId,
-      name: account.name,
-      homeDir: account.homeDir || "~",
-      color: account.color || meta.color,
-      source: "configured",
-      explicitId: account.id,
-      explicitIndex
-    });
-  });
-  if (autoAccounts) {
-    for (const account of autoAccounts) {
-      if (config.disabledProviders.includes(account.providerId)) continue;
-      const key = keyFor(account.providerId, account.homeDir);
-      if (configuredIds.has(account.id) || configuredKeys.has(key) || rowIds.has(account.id) || rowKeys.has(key)) continue;
-      const meta = PROVIDER_META[account.providerId];
-      rememberRow({
-        id: account.id,
-        providerId: account.providerId,
-        name: account.name,
-        homeDir: account.homeDir || "~",
-        color: account.color || meta.color,
-        source: "auto"
-      });
-    }
-  }
-  for (const providerId of PROVIDER_ORDER) {
-    if (config.disabledProviders.includes(providerId)) continue;
-    if (!tracked.has(providerId)) continue;
-    const key = keyFor(providerId, "~");
-    if (configuredIds.has(providerId) || configuredKeys.has(key) || rowIds.has(providerId) || rowKeys.has(key)) continue;
-    const meta = PROVIDER_META[providerId];
-    rememberRow({
-      id: providerId,
-      providerId,
-      name: meta.name,
-      homeDir: "~",
-      color: meta.color,
-      source: "auto"
-    });
-  }
-  return rows;
-}
-function clampNum(v, fallback, min) {
-  return typeof v === "number" && Number.isFinite(v) && v >= min ? v : fallback;
-}
-function isValidTimezone(tz) {
-  try {
-    new Intl.DateTimeFormat("en-CA", { timeZone: tz });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function validProvider(value) {
-  return PROVIDER_IDS.includes(value);
-}
-function sameJson(a, b) {
-  try {
-    return JSON.stringify(a) === JSON.stringify(b);
-  } catch {
-    return false;
-  }
-}
-function normalizeAllowedHost(value) {
-  if (typeof value !== "string") return null;
-  const candidate = value.trim();
-  if (!candidate) return null;
-  try {
-    const url = new URL(`http://${candidate}`);
-    if (url.username || url.password || url.port || url.pathname !== "/" || url.search || url.hash) return null;
-    const hostname = url.hostname.toLowerCase().replace(/\.$/, "");
-    if (!hostname || hostname.length > 253 || hostname.includes("*")) return null;
-    const labels = hostname.split(".");
-    if (labels.some((label) => !label || label.length > 63 || !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(label))) return null;
-    return hostname;
-  } catch {
-    return null;
-  }
-}
-function normalizeAllowedHosts(value) {
-  if (!Array.isArray(value)) return [];
-  const hosts = value.map(normalizeAllowedHost).filter((host) => host !== null);
-  return [...new Set(hosts)];
-}
-function repairConfig(input) {
-  const reasons = [];
-  const parsed = isRecord(input) ? input : {};
-  if (parsed !== input) reasons.push("config root was not an object");
-  const rawAccounts = Array.isArray(parsed.accounts) ? parsed.accounts : [];
-  if (!Array.isArray(parsed.accounts) && parsed.accounts !== void 0) reasons.push("accounts was not an array");
-  const accounts = [];
-  const accountIds = /* @__PURE__ */ new Set();
-  rawAccounts.forEach((raw, index) => {
-    if (!isRecord(raw)) {
-      reasons.push(`accounts[${index}] was not an object`);
-      return;
-    }
-    const providerId = raw.providerId ?? "claude";
-    if (!validProvider(providerId)) {
-      reasons.push(`accounts[${index}].providerId was invalid`);
-      return;
-    }
-    const id = typeof raw.id === "string" && raw.id.trim() ? raw.id.trim() : "";
-    const name = typeof raw.name === "string" && raw.name.trim() ? raw.name.trim() : "";
-    if (!id || !name) {
-      reasons.push(`accounts[${index}] was missing id or name`);
-      return;
-    }
-    if (accountIds.has(id)) {
-      reasons.push(`accounts[${index}].id was duplicated`);
-      return;
-    }
-    accountIds.add(id);
-    accounts.push({
-      id,
-      providerId,
-      name,
-      homeDir: typeof raw.homeDir === "string" && raw.homeDir.trim() ? raw.homeDir : "~",
-      ...typeof raw.color === "string" && raw.color.trim() ? { color: raw.color } : {}
-    });
-  });
-  const disabledProviders = (Array.isArray(parsed.disabledProviders) ? parsed.disabledProviders : []).filter(validProvider);
-  if (parsed.disabledProviders !== void 0 && !Array.isArray(parsed.disabledProviders)) {
-    reasons.push("disabledProviders was not an array");
-  }
-  const knownProviders = Array.isArray(parsed.knownProviders) ? parsed.knownProviders.filter(validProvider) : parsed.onboarded === true ? [...LEGACY_KNOWN] : [];
-  if (parsed.knownProviders !== void 0 && !Array.isArray(parsed.knownProviders)) {
-    reasons.push("knownProviders was not an array");
-  }
-  const allowedHosts = normalizeAllowedHosts(parsed.allowedHosts);
-  if (parsed.allowedHosts !== void 0 && !sameJson(parsed.allowedHosts, allowedHosts)) {
-    reasons.push("allowedHosts contained invalid or duplicate hostnames");
-  }
-  const activeAccountId = typeof parsed.activeAccountId === "string" && (accountIds.has(parsed.activeAccountId) || PROVIDER_IDS.includes(parsed.activeAccountId)) ? parsed.activeAccountId : null;
-  if (parsed.activeAccountId !== void 0 && parsed.activeAccountId !== null && activeAccountId === null) {
-    reasons.push("activeAccountId did not match a known account/provider");
-  }
-  const timezone = typeof parsed.timezone === "string" && parsed.timezone.trim() && isValidTimezone(parsed.timezone.trim()) ? parsed.timezone.trim() : null;
-  if (parsed.timezone !== void 0 && parsed.timezone !== null && timezone === null) {
-    reasons.push("timezone was invalid");
-  }
-  const config = {
-    ...DEFAULTS,
-    revision: typeof parsed.revision === "number" && Number.isSafeInteger(parsed.revision) && parsed.revision >= 0 ? parsed.revision : DEFAULTS.revision,
-    interval: clampNum(parsed.interval, DEFAULTS.interval, 1),
-    billingInterval: clampNum(parsed.billingInterval, DEFAULTS.billingInterval, 1),
-    clearScreen: typeof parsed.clearScreen === "boolean" ? parsed.clearScreen : DEFAULTS.clearScreen,
-    privacyMode: typeof parsed.privacyMode === "boolean" ? parsed.privacyMode : DEFAULTS.privacyMode,
-    privacyToggleKey: typeof parsed.privacyToggleKey === "string" && parsed.privacyToggleKey.length === 1 ? parsed.privacyToggleKey : DEFAULTS.privacyToggleKey,
-    timezone,
-    accounts,
-    activeAccountId,
-    disabledProviders,
-    onboarded: parsed.onboarded === true,
-    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,
-    allowedHosts,
-    resetDisplay: parsed.resetDisplay === "absolute" ? "absolute" : "relative",
-    knownProviders
-  };
-  for (const key of Object.keys(DEFAULTS)) {
-    if (!(key in parsed)) reasons.push(`missing ${key}`);
-  }
-  return { config, repaired: reasons.length > 0 || !sameJson(parsed, config), reasons };
-}
-function normalizeConfig(parsed) {
-  try {
-    return repairConfig(parsed).config;
-  } catch {
-    return { ...DEFAULTS };
-  }
-}
-function slugify(value) {
-  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 48);
-}
-function generateAccountId(name, existing) {
-  const base = slugify(name) || "account";
-  const taken = new Set(existing.map((a) => a.id));
-  if (!taken.has(base)) return base;
-  for (let i = 2; i < 1e3; i++) {
-    const candidate = `${base}_${i}`;
-    if (!taken.has(candidate)) return candidate;
-  }
-  return `${base}_${Date.now()}`;
-}
-function pickAccentColor(existing) {
-  const used = new Set(existing.map((a) => a.color).filter(Boolean));
-  for (const c of ACCENT_COLORS) {
-    if (!used.has(c)) return c;
-  }
-  return ACCENT_COLORS[existing.length % ACCENT_COLORS.length];
-}
-function sanitizeTyped(input) {
-  if (!input) return "";
-  return input.replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, "").replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/\x1bO./g, "").replace(/\x1b/g, "").replace(/[\x00-\x1f\x7f-\x9f]/g, "").replace(/\[20[01]~/g, "");
-}
-
-// src/config.ts
-function envDir(name) {
-  const v = process.env[name];
-  return v && v.trim() && isAbsolute(v.trim()) ? v.trim() : void 0;
-}
-function configDir() {
-  if (process.platform === "win32") {
-    return join(envDir("APPDATA") ?? join(homedir(), "AppData", "Roaming"), "tokmon");
-  }
-  return join(envDir("XDG_CONFIG_HOME") ?? join(homedir(), ".config"), "tokmon");
-}
-function configLocation() {
-  return join(configDir(), "config.json");
-}
-function cacheDir() {
-  if (process.platform === "win32") {
-    return join(envDir("LOCALAPPDATA") ?? envDir("APPDATA") ?? join(homedir(), "AppData", "Local"), "tokmon", "cache");
-  }
-  if (process.platform === "darwin") {
-    return join(homedir(), "Library", "Caches", "tokmon");
-  }
-  return join(envDir("XDG_CACHE_HOME") ?? join(homedir(), ".cache"), "tokmon");
-}
-function snapshotCacheFile() {
-  return join(cacheDir(), "web-snapshot.json");
-}
-async function loadConfig() {
-  let raw;
-  try {
-    raw = await readFile(configLocation(), "utf-8");
-  } catch {
-    return { ...DEFAULTS };
-  }
-  try {
-    await chmod(configDir(), 448);
-    await chmod(configLocation(), 384);
-  } catch {
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    try {
-      const dir = configDir();
-      await mkdir(dir, { recursive: true, mode: 448 });
-      await chmod(dir, 448);
-      const backup = configLocation() + ".bak";
-      await writeFile(backup, raw, { mode: 384 });
-      await chmod(backup, 384);
-    } catch {
-    }
-    return { ...DEFAULTS };
-  }
-  const repaired = repairConfig(parsed);
-  if (repaired.repaired) {
-    try {
-      await saveConfig(repaired.config);
-    } catch {
-    }
-  }
-  return repaired.config;
-}
-var saveQueue = Promise.resolve();
-var tempSequence = 0;
-function configTempFile(dir) {
-  tempSequence = (tempSequence + 1) % Number.MAX_SAFE_INTEGER;
-  return join(dir, `config.json.${process.pid}.${Date.now()}.${tempSequence}.tmp`);
-}
-function configJson(config) {
-  return JSON.stringify(normalizeConfig(config), null, 2) + "\n";
-}
-function saveConfig(config) {
-  const write = async () => {
-    const dir = configDir();
-    await mkdir(dir, { recursive: true, mode: 448 });
-    await chmod(dir, 448);
-    const tmp = configTempFile(dir);
-    try {
-      await writeFile(tmp, configJson(config), { mode: 384 });
-      await chmod(tmp, 384);
-      await rename(tmp, configLocation());
-    } catch (error) {
-      try {
-        await unlink(tmp);
-      } catch {
-      }
-      throw error;
-    }
-  };
-  const operation = saveQueue.catch(() => void 0).then(write);
-  saveQueue = operation;
-  return operation;
-}
-function saveConfigSync(config) {
-  const dir = configDir();
-  mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync(dir, 448);
-  const tmp = configTempFile(dir);
-  try {
-    writeFileSync(tmp, configJson(config), { mode: 384 });
-    chmodSync(tmp, 384);
-    renameSync(tmp, configLocation());
-  } catch (error) {
-    try {
-      unlinkSync(tmp);
-    } catch {
-    }
-    throw error;
-  }
-}
-function expandHome(p) {
-  if (!p) return homedir();
-  if (p === "~" || p === "~/" || p === "~\\") return homedir();
-  if (p.startsWith("~/") || p.startsWith("~\\")) return join(homedir(), p.slice(2));
-  return p;
-}
-function findAccount(config, id) {
-  if (!id) return null;
-  return config.accounts.find((a) => a.id === id) ?? null;
-}
-
-export {
-  PROVIDER_IDS,
-  DEFAULTS,
-  ACCENT_COLORS,
-  COLOR_PALETTE,
-  PROVIDER_META,
-  containsEmail,
-  redactEmail,
-  getTrackedAccountRows,
-  clampNum,
-  isValidTimezone,
-  normalizeAllowedHost,
-  normalizeAllowedHosts,
-  repairConfig,
-  normalizeConfig,
-  slugify,
-  generateAccountId,
-  pickAccentColor,
-  sanitizeTyped,
-  envDir,
-  configLocation,
-  cacheDir,
-  snapshotCacheFile,
-  loadConfig,
-  saveConfig,
-  saveConfigSync,
-  expandHome,
-  findAccount
-};

package/dist/chunk-M7XMV36F.js

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